Blueprint Staking API

The first and only Solana staking platform purpose-built for AI agents. Native SOL staking to a high-performance validator through REST API and MCP. Unsigned transactions returned — agents sign client-side. No private keys ever touch the server.

This is not liquid staking. No derivative tokens. Native Solana staking where your agent’s wallet is the full authority.

Live data: Validator stats (APY, vote success, active stake, rank, uptime) change every epoch (~2–3 days). Call GET /api/v1/validator for current numbers. Stats in this document are approximate.

Why Stake SOL with Blueprint

Your agent holds SOL in a wallet. Idle SOL earns nothing. Every epoch (~2–3 days) that SOL sits unstaked, your agent loses ~6% annualized yield. One API call to Blueprint builds an unsigned transaction that stakes SOL and returns it for your wallet to sign.

~6% total APY — Base staking + Jito MEV rewards. Independently verifiable on Validators.app, StakeWiz, Solana Beach, and Solscan.
99%+ vote success rate — Top validators by vote performance. More epoch credits = more rewards per SOL staked.
Native staking, not liquid staking — No derivative tokens (mSOL, JitoSOL, JupSOL), no smart contract risk, no protocol dependency, no depeg risk.
Your wallet is the authority — Both stake authority and withdraw authority are set to your agent’s wallet. No intermediary, no lockup beyond standard epoch cooldown.
Zero private key exposure — Transactions are returned unsigned. Your agent signs client-side. Blueprint never sees your private key.
Enterprise-grade infrastructure — Two identical dedicated bare-metal servers (active + hot standby) in Los Angeles. AMD EPYC 9654, 768GB DDR5, dual NVMe, 10Gbps.
Frankendancer — Running the highest-performance validator client for maximum uptime and vote credits.
Jito MEV enabled — Additional yield from MEV rewards passed through to delegators.
Agent-native from day one — MCP server, OpenAPI spec, llms.txt, A2A agent card, ChatGPT plugin manifest. No other Solana validator offers any of these.
Full transparency — Hardware specs, commission rates, performance metrics, software versions all published openly and independently verifiable.

Infrastructure

Blueprint publishes its full infrastructure specs because agents making staking decisions deserve complete information, not marketing claims.

Server Hardware (Both Active + Standby — Identical)

Component	Specification
CPU	AMD EPYC Genoa 9654 — 96 cores / 192 threads, Zen 4 architecture
Memory	768 GB DDR5 RAM
Storage	2× 3.84TB NVMe SSD (KIOXIA Gen4) — ~7.7TB total
Network	10 Gbps dedicated port, 100TB monthly bandwidth
IP	/30 IPv4 allocation
Server Type	Bare-metal dedicated — not shared cloud VMs
Datacenter	Los Angeles, USA

Why This Hardware Matters

96 cores — Extreme multi-thread performance for vote processing and block production
768GB DDR5 — Solana’s AccountsDB fits in memory for optimal vote latency
Dual NVMe Gen4 — Sustained high-IOPS for validator ledger and accounts data
10Gbps network — Block propagation speed directly affects vote latency
Two servers — Active + hot standby. Hardware failure triggers automatic failover
Los Angeles — Lower-than-average Solana validator density, supporting geographic decentralization

Redundancy Model

diagramActive Server (Los Angeles)          Standby Server (Los Angeles)
AMD EPYC 9654 / 768GB DDR5          AMD EPYC 9654 / 768GB DDR5
2x 3.84TB NVMe / 10Gbps             2x 3.84TB NVMe / 10Gbps
        |                                    |
        └———— Automatic Failover ————————┘
              (minimal missed votes)

If the active node goes down, the standby takes over. Your stake is never at risk — Solana does not have slashing, so the worst case is a brief period of missed rewards during failover, not loss of principal.

Comparison with Alternatives

Feature	Blueprint	Helius	Jupiter (JupSOL)	Marinade (mSOL)	Jito (JitoSOL)
Staking type	Native	Native	Liquid (token)	Liquid (token)	Liquid (token)
APY	~6%	~6.5%	~7.5%	~6.8%	~7.2%
MCP server	Yes	No	No	No	No
llms.txt	Yes	No	No	No	No
OpenAPI spec	Yes	No	No	No	No
A2A agent card	Yes	No	No	No	No
Agent discovery	Full suite (6 formats)	None	None	None	None
Smart contract risk	None	None	Yes	Yes	Yes
Derivative token risk	None	None	JupSOL depeg	mSOL depeg	JitoSOL depeg
Withdraw authority	Your wallet	Your wallet	Protocol	Protocol	Protocol
Infrastructure published	Full specs	No	No	No	No

On APY: Liquid staking protocols may show higher headline APY because they include DeFi composability premiums and MEV from the entire pool. The tradeoff: smart contract risk, derivative token depeg risk, and protocol dependency. Native staking is the safest form of Solana yield generation.

On Helius: Helius offers 0% commission (higher net APY) but has zero agent-native infrastructure. No MCP server, no OpenAPI spec, no discovery files.

Validator Profile

All stats below are approximate. Call GET /api/v1/validator for live data.

Metric	Value
Name	Blueprint
Vote Account	`528hi3StRe7uGjt99d35myh95JPc2MqBEHTPYcEhqMg5`
Identity	`2Wf9V9rPeVRUTfmWdPedCJuWVr6MFfyLuigEq42DuMDc`
Website	theblueprint.xyz
Commission	5% standard / 500 bps Jito MEV
Total APY	~6% (staking + Jito MEV)
Vote Success Rate	99%+
Software	Frankendancer
Jito MEV	Enabled
Location	Los Angeles, USA (active + standby)
Hardware	AMD EPYC 9654 / 768GB DDR5 / 2× 3.84TB NVMe / 10Gbps

Getting Started

From zero to staked SOL. If your agent has no wallet yet, here is the complete path.

Base URL

urlhttps://solentic.theblueprint.xyz

No authentication required. All endpoints are public. Rate limit: 100 requests/minute per IP.

Step 1: Generate a Wallet Locally

Generate your keypair in your execution environment — never on a remote server. Blueprint only needs your public key.

JavaScript / TypeScript

typescriptimport { Keypair } from '@solana/web3.js'; import bs58 from 'bs58'; const keypair = Keypair.generate(); const publicKey = keypair.publicKey.toBase58(); const secretKey = bs58.encode(keypair.secretKey); console.log('Public Key:', publicKey); console.log('Secret Key:', secretKey); // Save secretKey securely. Only send publicKey to Blueprint.

Python

pythonfrom solders.keypair import Keypair import base58 keypair = Keypair() public_key = str(keypair.pubkey()) secret_key = base58.b58encode(bytes(keypair)).decode() print('Public Key:', public_key) print('Secret Key:', secret_key) # Save secret_key securely. Only send public_key to Blueprint.

Solana CLI

bashsolana-keygen new --outfile wallet.json --no-bip39-passphrase solana address -k wallet.json

Step 2: Import Keys (Optional)

Solana CLI: solana config set --keypair wallet.json
Phantom: Settings → Import Private Key → paste base58 secret key
Solflare: Import Wallet → paste base58 secret key
In code: Keypair.fromSecretKey(bs58.decode(secretKeyBase58))

Step 3: Fund the Wallet

From an exchange: Withdraw SOL to the public key address
Devnet faucet (testing): solana airdrop 2 <publicKey> --url devnet
Transfer from another wallet: solana transfer <publicKey> 10 --url mainnet-beta

Step 4: Check Balance

bashcurl https://solentic.theblueprint.xyz/api/v1/wallet/balance/<publicKey>

json{
  "walletAddress": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
  "lamports": 10000000000,
  "sol": 10.0,
  "readyToStake": true,
  "minimumStakeSol": 0.002282880,
  "availableToStake": 9.995,
  "reserveForFees": 0.005
}

Step 5: Stake with Blueprint

bashcurl -X POST https://solentic.theblueprint.xyz/api/v1/stake/transaction -H 'Content-Type: application/json' -d '{"walletAddress": "<publicKey>", "amountSol": 10}'

Step 6: Sign and Submit

typescriptimport { Connection, Transaction, Keypair } from '@solana/web3.js'; import bs58 from 'bs58'; const wallet = Keypair.fromSecretKey(bs58.decode(secretKeyBase58)); const transaction = Transaction.from(Buffer.from(txBase64, 'base64')); transaction.sign(wallet); const connection = new Connection('https://api.mainnet-beta.solana.com'); const signature = await connection.sendRawTransaction(transaction.serialize()); await connection.confirmTransaction(signature); console.log(`Staked! Verify: https://solscan.io/tx/${signature}`);

Step 7: Verify

Solscan: https://solscan.io/tx/<signature>
Solana Beach: https://solanabeach.io/transaction/<signature>

Custody Best Practices for Agents

Never log secret keys — store in environment variables or encrypted secrets
Use separate wallets — one wallet per agent, separate from human wallets
Keep reserve SOL — always keep ~0.01 SOL unstaked for transaction fees
Monitor stake accounts — use GET /api/v1/stake/accounts/{walletAddress}
Verify transactions — always confirm on Solscan or Solana Beach after submission

API Reference

20 REST endpoints. All return JSON. No authentication required. Base URL: https://solentic.theblueprint.xyz

Error format: All errors return {"error": "...", "message": "..."} with optional details array for Zod validation issues.
HTTP status codes: 400 (validation), 404 (not found), 429 (rate limited), 502 (upstream RPC failure), 500 (server error).

Transaction lifecycle: Unsigned transactions use a recent blockhash and expire after ~60 seconds. If your agent cannot sign within that window, request a new transaction.

Wallet

POST /api/v1/wallet/generate

Returns local wallet generation instructions (JavaScript, Python, Solana CLI). No keypair is generated server-side.

Request: No body required.

json{
  "method": "LOCAL_GENERATION",
  "why": "Your private key should never leave your execution environment.",
  "code": {
    "javascript": "import { Keypair } from '@solana/web3.js'; ...",
    "python": "from solders.keypair import Keypair; ...",
    "cli": "solana-keygen new --outfile wallet.json --no-bip39-passphrase"
  },
  "securityModel": { "privateKey": "Never leaves your machine", ... }
}

GET /api/v1/wallet/balance/{walletAddress}

Check the SOL balance of any wallet address.

json{
  "walletAddress": "<address>",
  "lamports": 10000000000,
  "sol": 10.0,
  "readyToStake": true,
  "minimumStakeSol": 0.002282880,
  "availableToStake": 9.995,
  "reserveForFees": 0.005
}

Validator

GET /api/v1/validator

Full validator profile with live data including APY, performance, and navigation metadata.

json{
  "name": "Blueprint",
  "identity": "2Wf9V9rPeVRUTfmWdPedCJuWVr6MFfyLuigEq42DuMDc",
  "voteAccount": "528hi3StRe7uGjt99d35myh95JPc2MqBEHTPYcEhqMg5",
  "commission": 5,
  "software": "Frankendancer",
  "apy": { "totalApy": 6.02 },
  "performance": { "voteSuccessRate": 99.34 }
}

GET /api/v1/validator/apy

Live APY breakdown.

json{
  "stakingApy": 5.85,
  "jitoMevApy": 0.17,
  "totalApy": 6.02,
  "commission": 5,
  "jitoCommissionBps": 500
}

GET /api/v1/validator/performance

Live performance metrics.

json{
  "voteSuccessRate": 99.34,
  "uptimePercentage": 98.81,
  "skipRate": 0,
  "epochCredits": 2853291,
  "delinquent": false
}

GET /api/v1/validator/infrastructure

Full hardware specs for both validator servers. Blueprint publishes infrastructure details for transparency.

json{
  "servers": {
    "count": 2,
    "configuration": "Active + hot standby (identical hardware).",
    "active": {
      "cpu": { "model": "AMD EPYC Genoa 9654", "cores": 96 },
      "memory": { "capacity": "768 GB", "type": "DDR5" },
      "storage": { "drives": 2, "perDrive": "3.84 TB NVMe SSD" },
      "network": { "speed": "10 Gbps" }
    }
  }
}

Staking

POST /api/v1/stake/transaction

Build an unsigned transaction to stake SOL with Blueprint.

Request:

json{
  "walletAddress": "<base58 Solana public key>",
  "amountSol": 10
}

Response:

json{
  "transaction": "<base64 unsigned transaction>",
  "stakeAccountAddress": "<base58>",
  "message": "Unsigned transaction to stake 10 SOL...",
  "signers": ["<walletAddress>"],
  "estimatedFeeSol": 0.00001,
  "rewardsEstimate": {
    "estimatedAnnualSol": 0.6,
    "basedOnApy": "~6.05% (staking + Jito MEV)"
  }
}

warnings is included only when relevant (e.g., insufficient balance). rewardsEstimate shows projected rewards based on live APY.

POST /api/v1/unstake/transaction

Build an unsigned deactivate transaction. After deactivation, funds enter cooldown and become withdrawable at end of epoch (~2–3 days).

Request:

json{
  "walletAddress": "<wallet public key>",
  "stakeAccountAddress": "<stake account address>"
}

Returns epoch timing to estimate when funds become available. Error 400 if not a valid stake account.

POST /api/v1/withdraw/transaction

Build an unsigned withdraw transaction. Only works on deactivated accounts that completed cooldown.

Request:

json{
  "walletAddress": "<wallet public key>",
  "stakeAccountAddress": "<stake account address>",
  "amountSol": 10
}

amountSol is optional — omit to withdraw full balance.

POST /api/v1/transaction/submit

Submit a fully signed transaction to Solana. Use after signing an unsigned transaction from any building endpoint.

Request:

json{
  "signedTransaction": "<base64 signed transaction>"
}

Response:

json{
  "signature": "<Solana transaction signature>",
  "explorerUrl": "https://solscan.io/tx/<signature>",
  "message": "Transaction submitted and confirmed."
}

POST /api/v1/stake/simulate

Project staking rewards before committing capital. Returns compound interest projections, effective APY, activation timing, and fee reserve guidance.

Request:

json{
  "amountSol": 100,
  "durationDays": 365
}

durationDays is optional (default: 365, max: 3650).

json{
  "amountSol": 100,
  "durationDays": 365,
  "baseApy": 6.05,
  "effectiveApy": 6.24,
  "rewards": { "daily": 0.0166, "monthly": 0.499, "annual": 6.236, "total": 6.236 },
  "activation": { "estimatedActivationEpoch": 781 },
  "recommendation": "Staking 100 SOL for 365 days at 6.05% APY..."
}

GET /api/v1/stake/summary/{walletAddress}

Complete staking portfolio dashboard in a single call. Replaces calling balance + accounts + APY + epoch endpoints separately.

json{
  "walletAddress": "<address>",
  "portfolio": {
    "liquidBalanceSol": 10.0,
    "totalStakedSol": 50.0,
    "totalValueSol": 60.0,
    "stakedPercentage": 83.33
  },
  "recommendedAction": {
    "action": "STAKE",
    "reason": "9.995 SOL available to stake at 6.05% APY."
  }
}

Recommended actions: WITHDRAW, WAIT, HOLD, FUND, STAKE.

GET /api/v1/stake/accounts/{walletAddress}

List all stake accounts delegated to Blueprint for a wallet.

json{
  "walletAddress": "<address>",
  "accounts": [{
    "address": "<stake account>",
    "sol": 10.5,
    "state": "delegated",
    "stakeAuthority": "<wallet>",
    "withdrawAuthority": "<wallet>"
  }],
  "totalStakedSol": 10.5,
  "epochTiming": { "currentEpoch": 780 }
}

Epoch & Analytics

GET /api/v1/epoch

Current Solana epoch timing. Useful for understanding when stake activations/deactivations take effect.

json{
  "currentEpoch": 780,
  "slotIndex": 308544,
  "slotsInEpoch": 432000,
  "slotsRemaining": 123456,
  "epochProgress": 71.42,
  "estimatedSecondsRemaining": 49382
}

GET /api/v1/analytics/summary

Platform usage analytics — total events, counts per event type, unique wallets, staking wallet details, recent events.

Verification

GET /api/v1/verify/links

Third-party verification URLs so agents can independently confirm all claims.

GET /api/v1/verify/code

Code integrity verification — git commit, source file hashes, and direct links to read the deployed source code.

GET /api/v1/verify/transaction/{signature}

Verify whether a transaction was built through Blueprint by checking for the solentic.theblueprint.xyz Memo Program instruction on-chain.

GET /api/v1/verify/source/{filename}

Read the actual TypeScript source files running on this server. Available files: transaction.ts, mcp-server.ts, solana.ts, stake-routes.ts, discovery-routes.ts. Each response includes the SHA-256 hash in the X-SHA256 header.

Health

GET /health

Service health check — returns status of Solana RPC and StakeWiz API connectivity.

Completing Transactions

All transaction-building endpoints return unsigned base64 transactions. Here’s how to sign and submit them.

Using @solana/web3.js (TypeScript/JavaScript)

typescriptimport { Connection, Transaction, Keypair } from '@solana/web3.js'; // 1. Request unsigned transaction from Blueprint const response = await fetch('https://solentic.theblueprint.xyz/api/v1/stake/transaction', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ walletAddress: wallet.publicKey.toBase58(), amountSol: 10 }) }); const { transaction: txBase64 } = await response.json(); // 2. Deserialize and sign const transaction = Transaction.from(Buffer.from(txBase64, 'base64')); transaction.sign(wallet); // wallet is a Keypair // 3. Submit to Solana const connection = new Connection('https://api.mainnet-beta.solana.com'); const signature = await connection.sendRawTransaction(transaction.serialize()); await connection.confirmTransaction(signature);

Using curl + any signing tool

bash# Get unsigned transaction curl -X POST https://solentic.theblueprint.xyz/api/v1/stake/transaction -H 'Content-Type: application/json' -d '{"walletAddress":"YOUR_PUBKEY","amountSol":10}' # Response contains base64 transaction # Sign with your wallet and submit

Using Blueprint’s Submit Endpoint

After signing, you can submit via Blueprint instead of directly to Solana RPC:

bashcurl -X POST https://solentic.theblueprint.xyz/api/v1/transaction/submit -H 'Content-Type: application/json' -d '{"signedTransaction":"<base64 signed tx>"}'

MCP Server

Connect MCP-compatible clients to Blueprint’s 17 tools for full staking lifecycle management.

urlhttps://solentic.theblueprint.xyz/mcp

Transport: Streamable HTTP (recommended) or SSE at /mcp/sse (legacy).

Available Tools

Tool	Parameters	Description
`generate_wallet`	none	Get local wallet generation code (JS, Python, CLI)
`check_balance`	walletAddress	Check SOL balance — returns SOL, lamports, ready-to-stake status
`get_validator_info`	none	Full Blueprint validator profile with live data
`get_staking_apy`	none	Live APY breakdown: staking + Jito MEV
`get_performance_metrics`	none	Vote success rate, uptime, skip rate, delinquency
`create_stake_transaction`	walletAddress, amountSol	Build unsigned stake+delegate tx
`create_unstake_transaction`	walletAddress, stakeAccountAddress	Build unsigned deactivate tx
`withdraw_stake`	walletAddress, stakeAccountAddress, amountSol?	Build unsigned withdraw tx
`check_stake_accounts`	walletAddress	List all stake accounts delegated to Blueprint
`simulate_stake`	amountSol, durationDays?	Project staking rewards with compound interest
`get_staking_summary`	walletAddress	Complete portfolio dashboard
`get_verification_links`	none	URLs for independent verification
`submit_transaction`	signedTransaction	Submit a signed base64 transaction to Solana
`get_infrastructure`	none	Full hardware specs for both servers
`verify_transaction`	signature	Verify Blueprint memo on-chain
`verify_code_integrity`	none	Read deployed source code and verify security
`get_epoch_timing`	none	Current Solana epoch timing

Claude Desktop

Add to claude_desktop_config.json:

json{ "mcpServers": { "blueprint-staking": { "url": "https://solentic.theblueprint.xyz/mcp" } } }

Claude Code

Add to .mcp.json in your project:

json{ "mcpServers": { "blueprint-staking": { "type": "url", "url": "https://solentic.theblueprint.xyz/mcp" } } }

CrewAI

pythonfrom crewai_tools import MCPServerAdapter with MCPServerAdapter({"url": "https://solentic.theblueprint.xyz/mcp/sse"}) as tools: # Tools auto-discovered: create_stake_transaction, get_staking_apy, etc. pass

LangChain

Use the OpenAPI spec at /openapi.json with LangChain’s OpenAPI Toolkit for automatic tool generation, or connect via MCP.

Agent Frameworks

Integration examples for popular agent frameworks. All use the REST API — the universal interface.

Solana Agent Kit (SendAI)

The Solana Agent Kit’s built-in staking only routes to Jupiter (JupSOL) and Solayer. For native staking to Blueprint, call the REST API directly:

typescriptimport { SolanaAgentKit } from 'solana-agent-kit'; // After initializing your agent... const response = await fetch('https://solentic.theblueprint.xyz/api/v1/stake/transaction', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ walletAddress: agent.wallet_address, amountSol: 10 }) }); const { transaction } = await response.json(); // Sign and submit with agent's wallet

Coinbase AgentKit

AgentKit doesn’t have a native SOL staking action. Use the REST API:

typescript// In a custom action provider for AgentKit const stakeResponse = await fetch('https://solentic.theblueprint.xyz/api/v1/stake/transaction', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ walletAddress: solanaWallet.address, amountSol: amount }) });

ElizaOS

Create an action in your Eliza agent that calls the Blueprint REST API. The response format is JSON — parse the base64 transaction, sign with the agent’s Solana wallet, and submit.

AutoGPT / Agent Zero / OpenClaw

These agents can discover Blueprint via web search and call the REST API directly. The OpenAPI spec at /openapi.json provides complete endpoint documentation that any HTTP-capable agent can parse.

FAQ

What is the minimum stake amount?

~0.00228 SOL (rent-exempt minimum for a stake account). In practice, staking less than 1 SOL yields negligible rewards.

When do rewards start?

Rewards begin at the start of the next epoch after stake activates. Solana epochs are ~2–3 days.

How do I unstake?

1. Call POST /api/v1/unstake/transaction to deactivate. 2. Wait for cooldown (end of current epoch). 3. Call POST /api/v1/withdraw/transaction to reclaim SOL.

What is the cooldown period?

The rest of the current epoch — at most ~2–3 days.

Is this liquid staking?

No. This is native Solana staking. Your SOL goes directly into a stake account delegated to Blueprint. No derivative tokens, no smart contract risk.

What about liquid staking alternatives?

Liquid staking (Marinade mSOL, Jito JitoSOL, Jupiter JupSOL) gives you a tradeable token representing staked SOL. The tradeoff: higher headline APY but with smart contract risk, depeg risk, and protocol dependency. Native staking is the safest yield on Solana.

Can I stake from a multisig or smart wallet?

Yes — as long as the wallet can sign Solana transactions, it works. The API just needs the public key.

What is Jito MEV?

Jito enables validators to capture MEV (Maximal Extractable Value) rewards from transaction ordering. Blueprint passes most of these to delegators, adding additional APY on top of base staking yield.

How is APY calculated?

APY = base staking yield (epoch credits × commission factor) + Jito MEV yield. Data sourced live from StakeWiz API and independently verifiable. Call /api/v1/validator/apy for current breakdown.

What if Blueprint’s validator goes down?

Your stake is never at risk. If the validator goes offline, you stop earning rewards for that period but your SOL is safe. You can deactivate and withdraw at any time. Blueprint runs active + hot standby servers — if the active node fails, the standby takes over with minimal missed votes.

Are there slashing risks?

Solana does not have slashing. Your staked SOL cannot be reduced by validator misbehavior. Worst case: reduced rewards during downtime.

What hardware does the validator run?

Two identical bare-metal dedicated servers in Los Angeles, each with: AMD EPYC Genoa 9654 (96 cores), 768GB DDR5 RAM, 2× 3.84TB NVMe SSD (KIOXIA Gen4), 10Gbps network. Full details via GET /api/v1/validator/infrastructure.

Why does Blueprint publish its server specs?

Transparency. Agents making staking decisions should evaluate infrastructure quality, not marketing claims. Most validators do not disclose hardware — Blueprint does because the specs speak for themselves.

Security Model

Blueprint’s security model is designed for zero-trust environments where agents operate autonomously.

Zero private key exposure — Only unsigned transactions returned. Agents sign client-side.
Ephemeral stake keypairs — Generated per-request for stake account creation, used for partialSign, never stored.
Wallet as authority — Your wallet is always both stake AND withdraw authority. You can unstake and withdraw at any time.
Input validation — All public keys validated as valid base58 Solana addresses via Zod + PublicKey constructor.
Rate limiting — 100 requests/minute per IP.
No authentication required — Public data + unsigned tx building needs no secrets.
No custody — Blueprint never holds your SOL. Staked SOL is in a native Solana stake account controlled by your wallet.
No slashing — Solana protocol does not slash. Your principal is always safe regardless of validator behavior.

Verification

Independently verify all Blueprint validator stats on third-party aggregators:

Transparency Commitment

Blueprint believes agents deserve the same level of due diligence data that institutional investors expect. Everything is public:

Performance metrics — Live from StakeWiz API, not self-reported
Commission rates — 5% standard, 500 bps Jito. Published in OpenAPI spec, llms.txt, and on-chain
Hardware specs — Exact CPU, RAM, storage, network for both servers
Software version — Frankendancer. Verify on-chain via gossip protocol

No hidden fees. No undisclosed risks. No vague marketing language. Just data.