Chainwatch.
A self-hosted dashboard that indexes EVM contract events into your own Postgres and alerts you when they matter.
Chainwatch puts a UI on top of rindexer, the open-source EVM event indexer. Pick a chain, paste a contract address, choose the events you care about, and watch them land in a Postgres database you own. Browse and search them in the built-in explorer, export CSV, and set alert rules that send signed webhooks or emails. It runs in Docker next to your own Postgres, has no accounts and no telemetry, and your RPC keys never leave your server. Event data is only as correct as your RPC provider.
- 6
- chains with one-click RPC presets
- Any EVM
- chain through a custom RPC URL
- HMAC-SHA256
- signed webhook alerts
- 0
- telemetry, accounts or hosted services
A dashboard for the indexer you already trust.
These are real screenshots of Chainwatch running against USDC on Base and Ethereum, indexed into a local PostgreSQL.
Indexing you can see, search and act on.
rindexer does the heavy lifting. Chainwatch gives it a wizard, an explorer, alerts and a health view, all running next to your own database.
A wizard instead of YAML
Pick a chain, paste a contract address, choose the events and a starting block. Chainwatch checks your RPC, loads the ABI (pasted, or fetched from Etherscan with your own key) and writes the rindexer configuration for you.
Live overview and sync health
See engine status, events indexed per second, the indexed block against the chain head, and lag per indexer. A ticker across the top follows every chain you watch.
An explorer for decoded events
Browse each event table as it fills. Search any address, hash or value, page through history, hide internal columns, copy values, and export what you see as CSV. Token amounts use the decimals you set.
Signed webhook and email alerts
Build rules such as “Transfer where value is greater than 1,000,000,000”. Each delivery is signed with HMAC-SHA256 and a timestamp so your receiver can verify it. New rules watch future events only.
Your data stays in your Postgres
rindexer writes decoded events into tables you own and can query with any SQL tool. Deleting an indexer keeps its data unless you drop it yourself.
Private by construction
No accounts, no telemetry, no hosted service. Your RPC keys are passed to the engine through environment variables and never written into the configuration file. One admin password protects the dashboard.
Supervised engine
rindexer runs as a supervised process. If it crashes it restarts with backoff, and it comes back by itself after a container restart, resuming from the last block it indexed.
Presets and any EVM chain
One-click presets for USDC and USDT, RPC defaults for Ethereum, Base, Arbitrum, Optimism, Polygon and BNB Smart Chain, and a custom RPC URL for any other EVM network.
From contract address to live events.
- 1
Point it at a contract
Choose the chain and paste the contract address. Chainwatch tests the RPC and reads the contract's events from the ABI.
- 2
Pick events and a start block
Index only what you need, from now or from a specific block. Busy contracts produce millions of events, so start close to the present unless you need history.
- 3
Let the engine index
Chainwatch writes the configuration and runs rindexer. Events are decoded into Postgres and the overview updates live.
- 4
Explore and get alerted
Search the events, export them, and add rules that call your webhook or send an email when something matches.
name: chainwatch
project_type: no-code
networks:
- name: base
chain_id: 8453
# The RPC URL is read from the environment so it never sits in a file you might commit.
rpc: ${RPC_BASE}
storage:
postgres:
enabled: true
contracts:
- name: USDCBase
details:
- network: base
address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
start_block: 52228797
abi: ./abis/USDCBase.abi.json
include_events:
- TransferThe rindexer.yaml Chainwatch generated for the Base USDC indexer in the screenshots.
Running in a few minutes.
You need Docker and an RPC endpoint. Unzip the download and pick a path.
Option 1
Docker Compose
The supported way: Chainwatch, rindexer and Postgres together.
unzip chainwatch-1.0.0.zip && cd chainwatch-1.0.0
cp .env.example .env
# set POSTGRES_PASSWORD, ADMIN_PASSWORD and SESSION_SECRET (openssl rand -hex 32)
docker compose up -d --build
# open http://localhost:3000rindexer ships a linux/amd64 image only. On Apple Silicon use Rosetta emulation (colima start --vm-type vz --vz-rosetta, or Docker Desktop's Rosetta setting); the default QEMU emulation can crash Node.
Option 2
Put it behind HTTPS
The app listens on 127.0.0.1 only. Expose it through a reverse proxy.
# Caddyfile
chainwatch.example.com {
reverse_proxy 127.0.0.1:3000
}
# then, in .env
COOKIE_SECURE=trueDo not publish port 3000 directly. There is one admin password and no roles.
Option 3
Verify a webhook
Every alert is signed. Check the signature and the timestamp.
import crypto from "node:crypto";
export function verify(headers, rawBody, secret) {
const ts = headers["x-chainwatch-timestamp"];
const sig = headers["x-chainwatch-signature"] ?? "";
if (Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;
const expected =
"sha256=" + crypto.createHmac("sha256", secret).update(`${ts}.${rawBody}`).digest("hex");
return sig.length === expected.length &&
crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected));
}The signing secret is shown once, when you create the rule.
Built to be inspected.
A small Next.js app next to rindexer and Postgres. Every moving part is a plain file or a standard Docker service, so you can read it, change it, or debug it.
- 01
Your RPC
Any EVM node or provider
- 02
rindexer
Fetches and decodes logs
- 03
PostgreSQL
Event tables you own
- 04
Chainwatch
Overview, explorer, rules
- 05
Your systems
Webhook or email
What is in the box
src/appDashboard pages and API routes (Next.js)src/lib/supervisor.tsRuns and restarts rindexersrc/lib/rindexer-config.tsGenerates rindexer.yaml and ABI filessrc/lib/alerts.tsRule matching and signed deliveryDockerfileCopies rindexer from its official imagedocker-compose.ymlChainwatch and Postgres.env.exampleEvery setting, documentedTHIRD-PARTY-NOTICES.mdrindexer (MIT), fonts and dependencies
Stack
Third-party components keep their own licences, listed in THIRD-PARTY-NOTICES.md inside the download.
Your keys and data stay with you.
No telemetry, no accounts
Chainwatch makes no calls home. The only outbound requests are to the RPC endpoint you configure, to Etherscan if you add a key, and to the webhook or SMTP server of your alert rules.
Keys stay in the environment
RPC URLs are handed to rindexer through environment variables and are never written into the generated configuration file or the ABI files.
Your database, your data
Events land in your PostgreSQL. You can query, back up or delete them with the tools you already use.
What it is, and is not.
- It is only as accurate as your RPC provider. Public endpoints are rate-limited and not suitable for serious use.
- rindexer publishes an amd64 image only, so ARM machines run Chainwatch under emulation.
- Alerts are delivered once per matching event. A failed delivery is logged but not retried.
- One admin password and no roles: run it on a private network or behind your own authentication.
- Adding or changing an indexer restarts the engine, which briefly pauses all indexing.
- Not affiliated with the rindexer project. Free for personal, non-commercial use only.
Questions worth asking.
Do I need to know rindexer?
No. Chainwatch writes the rindexer configuration for you. If you do know rindexer, the generated rindexer.yaml and ABI files are plain files in the data volume.
Which chains does it support?
Any EVM chain you have an RPC URL for. Ethereum, Base, Arbitrum, Optimism, Polygon and BNB Smart Chain have one-click defaults.
Is my data sent anywhere?
No. Events are written to the PostgreSQL that comes with the Docker setup. Chainwatch only contacts your RPC, Etherscan (if you add a key), and the webhook or SMTP servers you configure.
Can I index all history of a busy contract?
You can, by choosing a starting block, but contracts like USDC produce millions of events. Speed depends on your RPC provider, so start near the present unless you need the history.
How do alerts work?
A rule watches one event, optionally with a condition on one field. Chainwatch checks for new rows every ten seconds and sends a signed webhook, an email, or both. New rules only watch future events.
Can I use it at work or for a client?
The freebie licence covers personal, non-commercial use. For commercial use, write to the studio.
Does it run on Apple Silicon?
Yes, under Rosetta emulation, because rindexer publishes an amd64 image only. See the quick start for the settings.
Free for you, owned by the studio.
Enter your email and we will send a private download link for Chainwatch v1.0.0. It is licensed to you for personal, non-commercial use only; Northline Studio owns the software and keeps all rights.
- Next.js dashboard and API source (TypeScript)
- Dockerfile and docker-compose.yml with Postgres
- .env.example, README.md, THIRD-PARTY-NOTICES.md, and LICENSE.txt
- Needs: Docker with Compose (on Apple Silicon: Rosetta emulation, since rindexer ships amd64 only)
- Needs: An RPC endpoint for each chain you index
- Needs: Optional: an Etherscan API key and an SMTP server
Read the full licence. Need commercial use? Write to hello@northlinestudio.dev.
Released 6 Oct 2026 · v1.0.0