Cube Runner Every Solana Block Back to Genesis

Standard getBlock on your constant-k Solana RPC endpoint, served from region caches and ledgers on every plan, and from long-term storage back to genesis on Blade Runner and Nexus plans.

Every Solana block since genesis on Blade Runner and Nexus plans
Standard getBlock on your existing endpoint: no new endpoint, no client change
Byte-identical responses, whichever source serves the block
Region caches, ledgers and the other regions' caches on every plan, including Free
New York, Frankfurt and Amsterdam

View Pricing Read the Cube Runner Docs View All Plan Limits

getBlock is served on every plan, including Free, from region caches, ledgers and the other regions' caches. Long-term storage back to genesis is included on Blade Runner and Nexus. Compare plans on the pricing page, see every limit on Plan Limits, and read the full reference in the Cube Runner docs. Cube Runner is part of Solana RPC.

What You Get

Back to Genesis

On Blade Runner and Nexus plans, getBlock can return any block since the genesis block, and getFirstAvailableBlock returns 0. Blocks that no cache, ledger or other region holds are retrieved from long-term storage.

Standard getBlock

Same parameters and responses as standard Solana getBlock: json, jsonParsed, base58 and base64, every transactionDetails level, rewards on or off, and legacy, version 0 and version 1 transactions. No new endpoint and no client change.

Byte-Identical Responses

The response is byte-identical whichever source serves the block: a cache, a ledger, another region or long-term storage.

Three Linked Regions

New York, Frankfurt and Amsterdam each keep their own block cache. A region asks the other regions before long-term storage, and copies the blocks it is missing from their caches in the background.

Popular Blocks Stay Longer

When space is needed, the oldest blocks leave first. A block requested several times in the last few hours stays until requests for it stop.

One Retrieval, Shared

A block requested by several API keys at once is retrieved once. It is then held in the region for at least 15 minutes and served to any API key on any plan.

Fair Queueing

Each plan has its own long-term storage queue in each region, shared by every API key on that plan, and API keys take turns. On an API key's turn, Cube Runner retrieves the key's queued block that the most API keys are waiting for. Among blocks with the same count, the newest goes first. API keys that make Cube Runner retrieve the same blocks again get fewer turns.

Clear Retry Signal

A block that is not ready within 25 seconds returns HTTP 429 with a Retry-After header and code -32019, and stays queued. The retry returns the block once it is retrieved.

How a Solana getBlock Request Is Answered

Each request is answered by the first source that holds the block.

Region cache, memory then diskRecent blocks, and older blocks that are requested often. All plans

Region ledgerThe blocks in the region's ledger window. All plans

Cache of another regionAsked only when that region holds the block. All plans

Long-term storageEvery block since genesis, at the plan's retrieval rate in each region. Blade Runner and Nexus

The depth of each cache depends on stored data, so it varies with block size and between regions. On Free and Operator plans, a block that no cache, ledger or other region holds returns code -32001 with the first available block.

Cube Runner by Plan

Limit	Free	Operator	Blade Runner	Nexus
Region Cache and Ledger	✓	✓	✓	✓
Other Regions' Caches	✓	✓	✓	✓
Long-Term Storage (every block since genesis)	Not included	Not included	✓	✓
Long-Term Storage Rate (per region, shared by all API keys on the plan)	Not included	Not included	1 block / 15 s	1 block / 3 s
Monthly Long-Term Storage Allowance (per API key, per region)	Not applicable	Not applicable	10,000 blocks	50,000 blocks
Blocks Queued per API Key	Not applicable	Not applicable	200	500
Blocks Queued per Region (all API keys on the plan)	Not applicable	Not applicable	1,000	2,000
Longest Allowed Queue Time (no guaranteed delivery, request again to requeue)	Not applicable	Not applicable	1 hour	2 hours
getFirstAvailableBlock Returns	Region depth	Region depth	0 (genesis)	0 (genesis)

Region depth: the oldest block from which the region holds every later block, in its cache or its ledger. Older blocks are still returned when a cache in any region holds them.
The monthly allowance counts only blocks retrieved from long-term storage for that API key. Blocks served by a cache, a ledger or another region never count.
Each region keeps its own count, so an API key has the full allowance in each region.
The allowance resets at 00:00 UTC on the first day of each month.
The getBlock rate limit on the Plan Limits page applies to every getBlock request, whichever source serves it.

Same Call, Same Endpoint

Send the standard getBlock request to your constant-k Solana RPC endpoint with your API key. There is no separate endpoint and no client change.

curl "https://rpc-newyork.constant-k.com/?api-key=YOUR_API_KEY" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getBlock",
    "params": [
      447946420,
      {
        "transactionDetails": "signatures",
        "rewards": false,
        "maxSupportedTransactionVersion": 1
      }
    ]
  }'

# Frankfurt:   https://rpc-frankfurt.constant-k.com/?api-key=YOUR_API_KEY
# Amsterdam:   https://rpc-amsterdam.constant-k.com/?api-key=YOUR_API_KEY
# Free and Operator plans: use a slot at or after the one getFirstAvailableBlock returns

Client Handling

On HTTP 429 with code -32019, wait the number of seconds in the Retry-After header (between 1 and 60), then send the same request again.
Repeat each queued request within 150 seconds. A queued block that gets no request for that long is dropped, and the next request queues it again.
When a block was not queued, was dropped from the queue, or was not returned by long-term storage, the 429 carries data.reason: queue_full, key_full, key_monthly, dropped or failed.
Treat only -32007 and -32009 as skipped slots. Code -32019 and HTTP 429 mean the block has not been served yet.
Set maxSupportedTransactionVersion to 1. Recent mainnet blocks mix legacy, version 0 and version 1 transactions, and without it getBlock returns -32015 for any block that contains a versioned transaction.
The Rust RpcClient retries up to 5 times and waits for Retry-After when it is under 120 seconds. @solana/web3.js 1.x retries 4 times with its own backoff and ignores Retry-After. @solana/kit does not retry.
A plan rate limit 429 (code -32005) carries no Retry-After header. Back off on your own before retrying.

FAQ

Do I need a new endpoint or a different SDK?

No. Cube Runner answers every getBlock request on your existing constant-k Solana RPC endpoint in New York, Frankfurt and Amsterdam. Parameters and responses are those of standard getBlock.

How far back can getBlock go?

On Blade Runner and Nexus plans, to the genesis block, and getFirstAvailableBlock returns 0. On Free and Operator plans, getBlock is served from caches and the region's ledger. getFirstAvailableBlock returns the oldest block from which the region holds every later block, and older blocks are still returned when a cache in any region holds them.

How long does an older block take?

Blocks from long-term storage are retrieved through one queue per plan in each region, shared by every API key on that plan, at 1 block per 15 seconds on Blade Runner and 1 block per 3 seconds on Nexus. A block retrieved within 25 seconds is returned in the same response. Otherwise your client gets a Retry-After wait, and the block stays queued while you keep requesting it, for at most 1 hour on Blade Runner and 2 hours on Nexus. Delivery time is not guaranteed.

What counts toward the monthly allowance?

Only blocks retrieved from long-term storage for your API key: 10,000 blocks on Blade Runner and 50,000 blocks on Nexus, per API key in each region. Blocks served by a cache, a ledger or another region never count. The allowance resets at 00:00 UTC on the first day of each month.

Does requesting the same block again count against my API key?

Not while a cache holds it. Requests served by a cache, a ledger or another region never count. Only retrieving a block again from long-term storage, after your API key received it in the last 24 hours, adds to a repeat count that gives the key fewer turns in the queue. The count halves every 6 hours. Like any retrieval from long-term storage, it also counts toward the monthly allowance.

Does Cube Runner cover getTransaction or getSignaturesForAddress?

No. Cube Runner serves getBlock only. History for getTransaction and getSignaturesForAddress ends at the region's ledger window, and minimumLedgerSlot returns its oldest slot.

Block History on Your Existing Endpoint

Long-term storage back to genesis is included on Blade Runner and Nexus plans. Region caches, ledgers and the other regions' caches are on every plan.

View Pricing Read the Cube Runner Docs