Running the Indexer

Use this page when the stream definitions are ready and you need to wire the runtime, database, migrations, and process shape.

Architecture

The typical Thru indexing stack looks like this:

Chain RPC -> @thru/replay ChainClient -> @thru/indexer runtime -> Postgres tables
                                                                     |
                                                                     v
                                                        app-owned queries/routes

Tech Stack Assumptions

The current @thru/indexer runtime assumes:

• PostgreSQL-backed tables generated through Drizzle
• a Drizzle database client passed as db
• a clientFactory that returns a ChainClient from @thru/replay
• Drizzle Kit or equivalent migration management
• a standalone Node service to run the indexer continuously

If you are not using Postgres plus Drizzle, start with the package reference for @thru/indexer and validate whether the current runtime fits your stack.

Runtime Setup

import { Indexer } from "@thru/indexer";
import { ChainClient } from "@thru/replay";
import { db } from "./db";
import tokenAccounts from "./account-streams/token-accounts";
import tokenTransfers from "./streams/token-transfers";

export function createIndexer() {
  return new Indexer({
    db,
    clientFactory: () => new ChainClient({ baseUrl: process.env.CHAIN_RPC_URL! }),
    eventStreams: [tokenTransfers],
    accountStreams: [tokenAccounts],
    defaultStartSlot: 0n,
    safetyMargin: 64,
    pageSize: 512,
    logLevel: "info",
  });
}

What Each Runtime Option Does

Option	What it controls
db	The Drizzle client used for inserts, updates, and checkpoints.
clientFactory	Fresh replay client creation for backfill and live streaming.
eventStreams	Append-only streams for event rows.
accountStreams	Current-state streams for account rows.
defaultStartSlot	Starting slot when no checkpoint exists yet.
safetyMargin	How far behind the live tip replay should stay during backfill-to-live switchover.
pageSize	How many records to request per backfill page.
logLevel	Runtime verbosity.

Checkpoints And Schema

Your Drizzle schema needs the checkpoint table plus every stream table.

export { checkpointTable } from "@thru/indexer";
export { tokenAccountsTable } from "./account-streams/token-accounts";
export { tokenTransferEvents } from "./streams/token-transfers";

Without checkpointTable, the runtime cannot resume safely after restarts.

Process Shape

In practice, most apps run the indexer as its own long-lived service:

1. load environment and connect to Postgres
2. run or verify migrations
3. build the Indexer
4. call await indexer.start()
5. stop gracefully on SIGTERM or SIGINT

const indexer = createIndexer();

process.on("SIGINT", () => indexer.stop());
process.on("SIGTERM", () => indexer.stop());

await indexer.start();

Reading The Results

The indexer writes standard Drizzle tables. Query those tables directly from your backend or expose routes owned by your application.

import { desc } from "drizzle-orm";
import { db } from "./db";
import { tokenTransferEvents } from "./schema";

export async function listRecentTransfers(limit = 50) {
  return await db
    .select()
    .from(tokenTransferEvents)
    .orderBy(desc(tokenTransferEvents.slot))
    .limit(limit);
}

Next Steps

• Open Querying Indexed Data once rows are landing in Postgres.
• See Build an Indexer for production guidance on worker/API separation, resumability, and live validation.
• See @thru/indexer and @thru/replay for full package references.