Coming soon
Rewind: Solana block history, the last 60 days
Rewind is a NoLimitNodes add-on, coming soon, that serves Solana historical block methods, such as getBlock, getBlocks and getTransaction, for the last 60 days. It will cost $200 a month on Pro and Ultra and be included in Max and Enterprise. For anything older, use the Historical Blocks archive.
- Historical block methods for the last 60 days
- Standard Solana JSON-RPC methods, called the way you already call them
- Coming soon: $200 a month on Pro and Ultra, included in Max and Enterprise
30 days ago
- Date (UTC)
- Slots back
- about 6,480,000
- Start slot
- currentSlot - 6,480,000
- Status
- Inside the Rewind window.
Reachable with RewindOlder than this is not in Rewind
A slot is about 400 ms, so a day is about 216,000 slots. The readout is that arithmetic, not a measurement.
What Rewind reaches, and what it leaves to the archive
Rewind answers method calls about the last 60 days. The Historical Blocks archive is the raw record from genesis, as files you download. They are different products for different jobs.
| Topic | Rewind | Historical Blocks |
|---|---|---|
| How far back | RewindThe last 60 days | Historical BlocksFrom genesis |
| What you get | RewindAn answer to a method call | Historical BlocksRaw getBlock JSON for any slot range |
| How you use it | RewindCall it like any Solana RPC method | Historical BlocksDownload the files, then process them yourself |
| Pick it for | RewindRecent history inside a live app, bot or dashboard | Historical BlocksReplays, custom indexers and model training over a long range |
Need both? They fit together: Rewind covers the last 60 days, and the archive covers everything before. See the Historical Blocks archive.
The methods
Standard Solana JSON-RPC methods, answered from the last 60 days of history. Each links to its reference in the docs.
| Method | Returns | Use it to |
|---|---|---|
| getBlock | ReturnsIdentity and transactions of a confirmed block | Use it toRead everything that landed in a slot |
| getBlocks | ReturnsThe confirmed blocks between two slots | Use it toList which slots in a range have a block |
| getBlocksWithLimit | ReturnsA set number of confirmed blocks from a slot | Use it toStep forward from a date, skipping empty slots |
| getBlockTime | ReturnsThe estimated production time of a block | Use it toPut a date on a slot |
| getTransaction | ReturnsOne confirmed transaction, by signature | Use it toInspect a past trade or a failed transaction |
| getSignaturesForAddress | ReturnsSignatures that touched an address, newest first, in pages | Use it toWalk a wallet or program history |
Find the block from 30 days ago
A date is not a slot, so the script turns days into a slot, lands on the first confirmed block at or after it (the exact slot may have been skipped), and reads it. Three methods, no library.
// block_days_ago.mts: read the first block from N days agoconst RPC = process.env.NLN_RPC_URL! // the RPC endpoint from your dashboardconst KEY = process.env.NLN_API_KEY!const DAYS = Number(process.argv[2] ?? 30) // Rewind reaches back 60 daysconst SLOTS_PER_DAY = 216_000 // 86,400 seconds at about 400 ms a slot
async function rpc<T>(method: string, params: unknown[]): Promise<T> { const res = await fetch(RPC, { method: 'POST', headers: { 'content-type': 'application/json', 'x-api-key': KEY }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }), }) const body = await res.json() if (body.error) throw new Error(`${method}: ${body.error.message}`) return body.result as T}
const now = await rpc<number>('getSlot', [{ commitment: 'finalized' }])const guess = now - DAYS * SLOTS_PER_DAY
// the guess can land on a skipped slot, so take the first confirmed block at or after itconst [slot] = await rpc<number[]>('getBlocksWithLimit', [guess, 1])const block = await rpc<{ blockTime: number | null; blockhash: string; signatures: string[] }>('getBlock', [ slot, { transactionDetails: 'signatures', rewards: false, maxSupportedTransactionVersion: 0 },])
const when = block.blockTime ? new Date(block.blockTime * 1000).toISOString() : 'unknown time'console.log(`slot ${slot} ${when}`)console.log(`blockhash ${block.blockhash}`)console.log(`${block.signatures.length} transactions`)# block_days_ago.py: read the first block from N days agoimport jsonimport osimport sysimport urllib.requestfrom datetime import datetime, timezone
RPC = os.environ["NLN_RPC_URL"] # the RPC endpoint from your dashboardKEY = os.environ["NLN_API_KEY"]DAYS = int(sys.argv[1]) if len(sys.argv) > 1 else 30 # Rewind reaches back 60 daysSLOTS_PER_DAY = 216_000 # 86,400 seconds at about 400 ms a slot
def rpc(method, params): request = urllib.request.Request( RPC, data=json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params}).encode(), headers={"content-type": "application/json", "x-api-key": KEY, "user-agent": "rewind-example"}, ) with urllib.request.urlopen(request) as response: body = json.load(response) if "error" in body: raise RuntimeError(f"{method}: {body['error']['message']}") return body["result"]
now = rpc("getSlot", [{"commitment": "finalized"}])guess = now - DAYS * SLOTS_PER_DAY
# the guess can land on a skipped slot, so take the first confirmed block at or after itslot = rpc("getBlocksWithLimit", [guess, 1])[0]block = rpc("getBlock", [slot, {"transactionDetails": "signatures", "rewards": False, "maxSupportedTransactionVersion": 0}])
when = datetime.fromtimestamp(block["blockTime"], timezone.utc).isoformat() if block.get("blockTime") else "unknown time"print(f"slot {slot} {when}")print(f"blockhash {block['blockhash']}")print(f"{len(block['signatures'])} transactions")# one block, once you have a slot from the last 60 days (getBlocksWithLimit returns one)curl "$NLN_RPC_URL" \ -H "content-type: application/json" \ -H "x-api-key: $NLN_API_KEY" \ -d '{"jsonrpc":"2.0","id":1,"method":"getBlock","params":[SLOT,{"transactionDetails":"signatures","rewards":false,"maxSupportedTransactionVersion":0}]}'export NLN_RPC_URL=your_endpointexport NLN_API_KEY=your_keynode block_days_ago.mts 30python3 block_days_ago.py 30slot 393520001 2026-09-13T19:16:32.000Zblockhash 5n3kQ…Hq9123 transactions- getSlot gives the current slot. Subtract days times about 216,000 for a starting guess.
- getBlocksWithLimit with a limit of 1 returns the first confirmed block at or after the guess, so a skipped slot does not break the lookup.
- getBlock reads it. With transactionDetails set to signatures the response stays small.
- The same steps work for any day from 1 to 60. For older ranges, use the Historical Blocks archive.
Questions Rewind answers
Each one is a job that needs recent history, with the method that does it.
Backtest a strategy
List the slots in a range, read each block, and replay your rules over real recent data before they trade.
getBlocksgetBlockAudit a wallet
Page through every signature that touched an address and open the ones you care about.
getSignaturesForAddressgetTransactionReconcile a bot’s fills
Check what actually landed for a signature, including whether it failed, against what your bot recorded.
getTransactionDate an event
Turn a slot from a log or a feed into a time, or a time into the block at that moment.
getBlockTimegetBlocksWithLimitRead one slot completely
Everything that landed in a single slot, to debug a failed transaction or study a busy moment.
getBlock
Count a wallet’s activity per day
A short Python script that pages through a wallet’s signatures and prints how many landed each day, and how many of those failed. It stops when it reaches the day you asked for.
# wallet_days.py: count a wallet's transactions per dayimport jsonimport osimport sysimport timeimport urllib.requestfrom collections import Counterfrom datetime import datetime, timezone
RPC = os.environ["NLN_RPC_URL"] # the RPC endpoint from your dashboardKEY = os.environ["NLN_API_KEY"]ADDRESS = sys.argv[1]DAYS = int(sys.argv[2]) if len(sys.argv) > 2 else 7 # Rewind reaches back 60 daysPAGE = 1000 # the most getSignaturesForAddress returns at once
def rpc(method, params): request = urllib.request.Request( RPC, data=json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params}).encode(), headers={"content-type": "application/json", "x-api-key": KEY, "user-agent": "rewind-example"}, ) with urllib.request.urlopen(request) as response: body = json.load(response) if "error" in body: raise RuntimeError(f"{method}: {body['error']['message']}") return body["result"]
cutoff = time.time() - DAYS * 86_400per_day, failed = Counter(), Counter()before = Nonereached_cutoff = False
while not reached_cutoff: config = {"limit": PAGE} if before: config["before"] = before page = rpc("getSignaturesForAddress", [ADDRESS, config]) for item in page: when = item.get("blockTime") if when is None: continue if when < cutoff: reached_cutoff = True # newest first, so everything after this is older break day = datetime.fromtimestamp(when, timezone.utc).strftime("%Y-%m-%d") per_day[day] += 1 if item["err"] is not None: failed[day] += 1 if len(page) < PAGE: break before = page[-1]["signature"]
for day in sorted(per_day): note = f" ({failed[day]} failed)" if failed[day] else "" print(f"{day} {per_day[day]:>6,}{note}")print(f"{sum(per_day.values()):,} transactions in {len(per_day)} days")export NLN_RPC_URL=your_endpointexport NLN_API_KEY=your_keypython3 wallet_days.py YOUR_WALLET_ADDRESS 72026-10-08 143 (3 failed)2026-10-09 2012026-10-10 187 (1 failed)…1,042 transactions in 7 days- It uses only getSignaturesForAddress, a page of up to 1,000 signatures at a time.
- Python standard library only: no packages to install.
- The output block shows the format only. The numbers are not from a real wallet.
Coming soon: add it, or choose a plan that includes it
Rewind will be $200 a month on Pro and Ultra. Max and Enterprise will include it.
Pro
60 days of blocks
Pro $49/mo + Rewind $200/mo when it opens
$249/mo
Ultra
60 days of blocks
Ultra $199/mo + Rewind $200/mo when it opens
$399/mo
Max
60 days of blocks
Rewind included when it opens
$300/mo
Enterprise
60 days of blocks
Rewind included when it opens
$500/mo
Start reading history in three steps
- 1
Add Rewind
When it opens, add it to Pro or Ultra, or choose Max or Enterprise, which include it.
- 2
Call a block method
Send the request to the endpoint in your dashboard with your API key, as in the Solana RPC reference. The examples above use environment variables for both.
- 3
Ask about the last 60 days
Pass a slot, a signature or an address from the last 60 days and the answer comes back like any other RPC call.
Rewind: questions
Not here? Email [email protected] or talk to sales.
What is Rewind?
Rewind is a NoLimitNodes add-on that serves Solana historical block methods for the last 60 days: getBlock, getBlocks, getBlocksWithLimit, getBlockTime, getTransaction and getSignaturesForAddress. You call them the way you call any Solana JSON-RPC method.
How far back does Rewind go?
The last 60 days. For anything older, such as a replay from genesis, use the Historical Blocks archive, which is raw getBlock data for any slot range.
How much does Rewind cost?
Rewind is coming soon. It will be $200 a month on Pro and Ultra, and included in Max and Enterprise at no extra charge.
How do I turn a date into a slot?
A slot is about 400 milliseconds, so a day is about 216,000 slots. Subtract days times that number from the current slot from getSlot for a starting guess, then call getBlocksWithLimit with a limit of 1 to land on the first confirmed block at or after it. getBlockTime then confirms the time.
What happens if I ask for a skipped slot?
A skipped slot has no block, so getBlock reports that the slot was skipped or is missing. Use getBlocks or getBlocksWithLimit to find slots that do have a block, and read those.
Do I need to change my code or libraries?
No. These are standard Solana JSON-RPC methods, so existing clients and libraries work. Your dashboard shows the endpoint and API key to use.
Rewind or Historical Blocks: which do I need?
Choose Rewind when an app, bot or dashboard needs recent history by method call, up to 60 days back. Choose Historical Blocks when you need the raw record over a long range or from genesis, as files you process yourself.
When can I get Rewind?
Rewind is coming soon. We have not set a date to publish here. Email [email protected] and we will tell you when it opens.
Rewind is coming soon.
The last 60 days of Solana blocks, one method call away. +$200 a month on Pro and Ultra, included in Max and Enterprise.
Questions first? Email [email protected] or talk to sales.