Ankr + Midnight Network RPC

Use Ankr Chain RPC as your Midnight node endpoint for testnet and mainnet.

What this skill produces: working Ankr HTTPS/WSS URLs with API key, a small JSON-RPC client, midnight-js network config wired to Ankr, and call patterns for Midnight operations.

Primary references:

• Ankr Midnight RPC
• Ankr Midnight API docs
• Ankr API key / Premium basics
• Related skills: midnight-rpc/, midnight-js/, multinetwork/, indexer/

Critical: Midnight ≠ Ankr.js Advanced API

@ankr.com/ankr.js (AnkrProvider) talks to Ankr Advanced API (ankr_getNFTsByOwner, getAccountBalance, …). Those methods are for EVM chains only (eth, polygon, bsc, …).

Midnight is not in the Advanced API chain list. Do not use:

// ❌ Wrong for Midnight — Advanced API / EVM only
import { AnkrProvider } from '@ankr.com/ankr.js';
const provider = new AnkrProvider('YOUR_ADVANCED_API_ENDPOINT');
await provider.getNFTsByOwner({ blockchain: 'eth', walletAddress: '0x…' });

For Midnight, use Ankr Node / Chain RPC: plain JSON-RPC POST to:

https://rpc.ankr.com/midnight_testnet/<API_KEY>
https://rpc.ankr.com/midnight_mainnet/<API_KEY>

Auth is the API key in the URL path — no Authorization header.

Workflow

1. Sign in to Ankr RPC and create/select a project
2. Enable Midnight and copy HTTPS (and optionally WSS) endpoints
3. Store the full URL (with key) in env — never commit the key
4. Point midnight-js node / rpc at the Ankr URL
5. Call Midnight JSON-RPC methods (midnight_*, system_*, chain_*, …)
6. Keep Indexer GraphQL separate (Ankr RPC ≠ Midnight Indexer)

1) Get your Ankr API key and Midnight endpoints

Sign in

1. Open https://www.ankr.com/rpc/
2. Sign in (Google, Ethereum wallet, GitHub, X, etc.)
3. Create or open a Project (Projects pane)

Premium / paid plans unlock higher rate limits and private endpoints. Free/demo access may be rate-limited — prefer a project key for apps.

Copy Midnight endpoints

1. In the project, open Chains
2. Select Midnight
3. Choose network:
   • Testnet → midnight_testnet
   • Mainnet → midnight_mainnet
4. Copy HTTPS (required) and WSS (optional, for subscriptions / some SDKs)

URL shape

HTTPS: https://rpc.ankr.com/<network>/<API_KEY>
WSS:   wss://rpc.ankr.com/<network>/<API_KEY>

Formula: Endpoint = Project (API key) + Network.

Official Ankr request examples use a trailing slash:

https://rpc.ankr.com/midnight_testnet/YOUR_ANKR_API_KEY/

Both with and without trailing slash usually work; keep one style consistently.

Env vars (recommended)

# .env.local — never commit
ANKR_API_KEY=your_project_api_key_here

# Or store the full endpoint
ANKR_MIDNIGHT_TESTNET_RPC=https://rpc.ankr.com/midnight_testnet/your_project_api_key_here
ANKR_MIDNIGHT_MAINNET_RPC=https://rpc.ankr.com/midnight_mainnet/your_project_api_key_here

# Optional WebSocket
ANKR_MIDNIGHT_TESTNET_WSS=wss://rpc.ankr.com/midnight_testnet/your_project_api_key_here
ANKR_MIDNIGHT_MAINNET_WSS=wss://rpc.ankr.com/midnight_mainnet/your_project_api_key_here

Build URLs in code if you only store the key:

const ANKR_KEY = process.env.ANKR_API_KEY!;
if (!ANKR_KEY) throw new Error('Missing ANKR_API_KEY');

export const ANKR_MIDNIGHT = {
  testnet: {
    http: `https://rpc.ankr.com/midnight_testnet/${ANKR_KEY}`,
    wss: `wss://rpc.ankr.com/midnight_testnet/${ANKR_KEY}`,
  },
  mainnet: {
    http: `https://rpc.ankr.com/midnight_mainnet/${ANKR_KEY}`,
    wss: `wss://rpc.ankr.com/midnight_mainnet/${ANKR_KEY}`,
  },
} as const;

2) Smoke-test the endpoint

curl -X POST "https://rpc.ankr.com/midnight_testnet/${ANKR_API_KEY}/" \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "method": "system_chain",
    "params": [],
    "id": 1
  }'

Expected shape:

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": "testnet-02-1"
}

Quick health check:

curl -X POST "https://rpc.ankr.com/midnight_testnet/${ANKR_API_KEY}/" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"system_health","params":[],"id":1}'

3) Minimal TypeScript JSON-RPC client (Midnight)

No @ankr.com/ankr.js required for Midnight.

type JsonRpcId = number | string;

export async function ankrMidnightRpc<T = unknown>(
  endpoint: string,
  method: string,
  params: unknown[] = [],
  id: JsonRpcId = 1,
): Promise<T> {
  const res = await fetch(endpoint, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ jsonrpc: '2.0', method, params, id }),
  });

  if (!res.ok) {
    throw new Error(`Ankr RPC HTTP ${res.status}: ${await res.text()}`);
  }

  const payload = (await res.json()) as {
    result?: T;
    error?: { code: number; message: string; data?: unknown };
  };

  if (payload.error) {
    throw new Error(`Ankr RPC ${payload.error.code}: ${payload.error.message}`);
  }

  return payload.result as T;
}

Usage:

const rpc = process.env.ANKR_MIDNIGHT_TESTNET_RPC!;

const chain = await ankrMidnightRpc<string>(rpc, 'system_chain');
const health = await ankrMidnightRpc<{
  peers: number;
  isSyncing: boolean;
  shouldHavePeers: boolean;
}>(rpc, 'system_health');

const apiVersions = await ankrMidnightRpc<number[]>(rpc, 'midnight_apiVersions');

4) Wire Ankr into midnight-js / multinetwork config

Midnight dApps typically need three services. Ankr replaces only the node RPC:

Drop-in network config

import { ANKR_MIDNIGHT } from './ankr';

// Map Ankr "testnet" to your app's Midnight testnet target
// (preview/preprod naming differs by SDK version — use the network your app deploys to)
export const networks = {
  testnet: {
    // Keep official indexer unless you have another GraphQL provider
    indexerHttp: 'https://indexer.preprod.midnight.network/api/v4/graphql',
    indexerWs: 'wss://indexer.preprod.midnight.network/api/v4/graphql/ws',
    // Ankr node RPC (HTTPS). Some midnight-js setups expect WSS — use ANKR_MIDNIGHT.testnet.wss then.
    rpc: ANKR_MIDNIGHT.testnet.http,
    proofServerUrl: 'http://127.0.0.1:6300',
  },
  mainnet: {
    indexerHttp: 'https://indexer.mainnet.midnight.network/api/v4/graphql',
    indexerWs: 'wss://indexer.mainnet.midnight.network/api/v4/graphql/ws',
    rpc: ANKR_MIDNIGHT.mainnet.http,
    proofServerUrl: 'https://api.1am.xyz',
  },
};

Where example skills use node = 'https://rpc.preprod.midnight.network', replace with the Ankr HTTPS URL (or WSS if the provider builder requires WebSocket).

Network naming note: Ankr exposes midnight_testnet / midnight_mainnet. Midnight apps often use preview / preprod / mainnet. Confirm which public Midnight network Ankr’s midnight_testnet tracks (system_chain → e.g. testnet-02-1) before deploying contracts against it.

5) Operations (JSON-RPC methods on Ankr Midnight)

Full method catalog: Ankr Midnight docs and skill midnight-rpc/.

A) Midnight-specific (primary for dApps)

const state = await ankrMidnightRpc(
  rpc,
  'midnight_jsonContractState',
  ['<contract-address>'], // omit second arg for latest
);

const zswap = await ankrMidnightRpc(
  rpc,
  'midnight_zswapChainState',
  ['<contract-address>'],
);

const versions = await ankrMidnightRpc(rpc, 'midnight_apiVersions');

B) System / health

await ankrMidnightRpc(rpc, 'system_chain');
await ankrMidnightRpc(rpc, 'system_syncState');

C) Chain & blocks

const head = await ankrMidnightRpc<string>(rpc, 'chain_getFinalizedHead');
const block = await ankrMidnightRpc(rpc, 'chain_getBlock', [head]);

D) State & storage

E) Archive (historical)

F) Sidechain / Partnerchain

G) Accounts, GRANDPA, child state, meta

const methods = await ankrMidnightRpc(rpc, 'rpc_methods');

6) What Ankr does not replace on Midnight

Troubleshooting

Related Skills

Sources

• https://www.ankr.com/rpc/midnight/
• https://www.ankr.com/docs/rpc-service/chains/chains-api/midnight/
• https://www.ankr.com/docs/rpc-service/getting-started/basics-premium/
• https://www.ankr.com/docs/advanced-api/javascript-sdk/ (EVM Advanced API — not Midnight)
• https://www.npmjs.com/package/@ankr.com/ankr.js