Bridge Hub – Polkadot's Trustless Interoperability Parachain

Bridge Hub RPC
With Dwellir, you get access to our global Bridge Hub network which always routes your API requests to the nearest available location, ensuring low latency and the fastest speeds.

Get your API key →

Why Build on Bridge Hub?

Bridge Hub is Polkadot's system parachain dedicated to secure cross-network connectivity. It hosts bridge light clients, routing logic, and XCM tooling that allow ecosystems such as Kusama and Ethereum to interoperate without trusted third parties.

🔐 Trustless Finality

On-chain GRANDPA & BEEFY verification – Embedded light clients validate both Polkadot and bridged consensus, enabling permissionless relayers.
Optimistic root tracking – Finality proofs are persisted so downstream chains can verify historical headers.
Governed suspension modes – Bridge operators can pause lanes per pallet when anomalies are detected.

🌉 Multi-Chain Connectors

Polkadot ↔ Kusama routing – Bridge Westend/Bridge Bulletin pallets exchange relay-chain and parachain headers between ecosystems.
Snowbridge (Polkadot ↔ Ethereum) – Native integration of Snowbridge pallets for ERC-20 asset movement and message passing with Ethereum mainnet.
Message fan-out – Bridge Bulletin instances distribute payloads to partner chains without duplicating relayer work.

🧩 Specialized Pallets

pallet_bridge_grandpa – Stores bridged finality proofs and validator sets.
pallet_bridge_parachains – Syncs parachain headers required for XCM and HRMP messaging.
pallet_bridge_messages – Manages outbound/inbound lanes, delivery proofs, and fee accounting for cross-chain messages.
pallet_xcm_bridge_hub – Provides XCM helpers for routing assets and arbitrary instructions over bridge lanes.

Quick Start with Bridge Hub

Connect to Bridge Hub using Dwellir's low-latency infrastructure:

🔗 RPC Endpoints

Polkadot

Mainnet

Production Bridge Hub parachain.

WSS

wss://api-bridge-hub-polkadot.n.dwellir.com/YOUR_API_KEY

✓ Archive Node✓ Trace API✓ Debug API✓ WebSocket✓ BEEFY proofs✓ Bridge pallets

Quick Connect:

curl -X POST https://api-bridge-hub-polkadot.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"chain_getBlock","params":[],"id":1}'

Multi-network Access

Dwellir maintains Bridge Hub connectivity across Polkadot environments:

Polkadot Bridge Hub – Production-grade routing parachain for trustless bridging.
Westend Bridge Hub – Official Polkadot testnet used for validating upgrades before mainnet rollout.
Paseo Bridge Hub – Community-driven public testnet mirroring upcoming Polkadot features.
Kusama Bridge Hub – Economic canary network that ships features before Polkadot.

Installation & Setup

Polkadot.js
Substrate API (Rust)
Python (py-substrate-interface)
Direct JSON-RPC

import { ApiPromise, WsProvider } from '@polkadot/api';

// Connect to Bridge Hub
const provider = new WsProvider('wss://api-bridge-hub-polkadot.n.dwellir.com/YOUR_API_KEY');
const api = await ApiPromise.create({ provider });

// Confirm we are on Bridge Hub
const [chain, version] = await Promise.all([
  api.rpc.system.chain(),
  api.rpc.system.version()
]);
console.log(`Connected to ${chain} v${version}`);

// Inspect the latest bridged Westend finality proof
const bestWestendFinality = await api.query.bridgeWestendGrandpa.bestFinalized();
console.log('Best Westend header finalized on Bridge Hub:', bestWestendFinality.toString());

// Track Snowbridge outbound lane metrics
const outboundLanes = await api.query.bridgeWestendMessages.outboundLanes.entries();
outboundLanes.slice(0, 1).forEach(([key, value]) => {
  console.log('Outbound lane', key.args[0].toString(), value.toHuman());
});

use jsonrpsee::rpc_params;
use substrate_api_client::{rpc::JsonrpseeClient, Api, GetBlockHash};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = JsonrpseeClient::with_url("https://api-bridge-hub-polkadot.n.dwellir.com/YOUR_API_KEY").await?;
    let api = Api::new(client).await?;

    // Fetch parachain head
    let head = api.get_finalized_head().await?;
    println!("Latest Bridge Hub head: {head}");

    // Query BEEFY justification root published by Bridge Hub
    let beefy_head: Option<String> = api
        .rpc()
        .request("beefy_getFinalizedHead", rpc_params![])
        .await?;
    println!("Latest BEEFY finalized head: {:?}", beefy_head);

    // Inspect permissionless lane pallet state
    let storage_key = api.metadata().storage_map_key(
        "BridgeRelayersForPermissionlessLanes",
        "RelayerConfig",
        &0u32,
    )?;
    let config: Option<Vec<u8>> = api.get_storage_by_key(storage_key, None).await?;
    println!("Permissionless relayer config: {:?}", config);

    Ok(())
}

from substrateinterface import SubstrateInterface

substrate = SubstrateInterface(
    url="wss://api-bridge-hub-polkadot.n.dwellir.com/YOUR_API_KEY"
)

chain_name = substrate.rpc_request("system_chain", [])
print("Chain:", chain_name["result"])

# Retrieve head committed to the Kusama bridge lane
best_header = substrate.query(
    module='BridgeWestendGrandpa',
    storage_function='BestFinalized'
)
print("Best bridged Westend header:", best_header)

# Check outbound message lane status for Snowbridge
lane_status = substrate.query(
    module='EthereumOutboundQueue',
    storage_function='Outbox',
    params=[0]
)
print("Snowbridge outbound lane 0 status:", lane_status.value)

# Discover supported RPC namespaces
curl -X POST https://api-bridge-hub-polkadot.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "rpc_methods",
    "params": [],
    "id": 1
  }'

# Fetch latest bridged Westend block hash
curl -X POST https://api-bridge-hub-polkadot.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "state_call",
    "params": [
      "BridgeWestendGrandpa_finalityApi_bestFinalized",
      "0x"
    ],
    "id": 2
  }'

Network Information

Genesis Hash

0xdcf691b5...

Bridge Hub (Polkadot)

Block Time

6 seconds

Aura + Relay finality

Native Token

DOT

Fees paid via Relay Chain

Parachain ID

1002

Polkadot system parachain

Network Details

Relay Chain: Polkadot
Genesis Hash: 0xdcf691b5a3fbe24adc99ddc959c0561b973e329b1aef4c4b22e7bb2ddecb4464
Consensus: Collator-produced blocks with Polkadot relay GRANDPA finality
Bridged Counterparts: Kusama (Westend), Bridge Bulletin, Ethereum (Snowbridge)
Security: On-chain slashable relayer incentives via pallet_bridge_relayers

Available JSON-RPC Methods

Bridge Hub exposes the standard Substrate namespaces alongside bridge-specific RPCs for GRANDPA, BEEFY, and Snowbridge messaging. Use the tables below to jump straight to the reference pages that match your integration needs.

Core Substrate namespaces

Group	Purpose	Key Methods
`system_*`	Node health, network peers, runtime properties	`system_health`, `system_version`, `system_properties`
`chain_*`	Blocks, headers, and finality subscriptions	`chain_getHeader`, `chain_getFinalizedHead`, `chain_subscribeNewHeads`
`state_*`	Storage reads, metadata, runtime calls	`state_getStorage`, `state_getRuntimeVersion`, `state_getKeysPaged`
`author_*`	Extrinsic submission lifecycle	`author_submitExtrinsic`, `author_submitAndWatchExtrinsic`, `author_pendingExtrinsics`
`grandpa_*`	Finality gadget status for the parachain	`grandpa_roundState`
`rpc_methods`	Discover every enabled namespace	`rpc_methods`

Bridge & BEEFY namespaces

Namespace	Purpose	Methods
`beefy_*`	Inspect the latest BEEFY justifications broadcast to Snowbridge	`beefy_getFinalizedHead`
`bridge_grandpa_*`	Generate GRANDPA finality proofs for bridged relay chains	`bridge_grandpa_getProof`
`bridge_messages_*`	Produce outbound lane proofs for Snowbridge and Kusama connections	`bridge_messages_getProof`

Bridge Protocols

Snowbridge (Ethereum ↔ Polkadot)

BEEFY light client verifies Ethereum finality proofs and publishes outbound commitments.
Inbound queue accepts ERC-20 and arbitrary message payloads via event proofs.
Outbound queue batches Polkadot-origin messages and anchors them on Ethereum.

Kusama Bridge (Westend ↔ Polkadot)

BridgeWestendGrandpa pallet syncs Westend finality headers and validator sets.
BridgeWestendParachains tracks parachain heads to validate XCM and HRMP messages.
BridgeWestendMessages exposes lane metrics, delivery confirmations, and fee accounting.

Bridge Bulletin

Polkadot Bulletin acts as a hub-and-spoke relay for partners requiring broadcast style delivery.
Permissionless lanes allow new chains to request connectivity without runtime upgrades.

XCM Integration

Bridge Hub exposes pallet_xcm_bridge_hub helpers for routing XCM messages over bridge lanes.

import { ApiPromise, WsProvider } from '@polkadot/api';
import { BN } from '@polkadot/util';

const api = await ApiPromise.create({
  provider: new WsProvider('wss://api-bridge-hub-polkadot.n.dwellir.com/YOUR_API_KEY')
});

const laneId = 0; // Snowbridge outbound lane
const beneficiary = {
  parents: 2,
  interior: { X1: { AccountId32: { network: 'Any', id: '0x...' } } }
};
const assets = {
  parents: 1,
  interior: 'Here'
};

const tx = api.tx.xcmBridgeHub.sendAssetsOverBridge(
  laneId,
  beneficiary,
  assets,
  new BN('100000000000'),
  'Unlimited'
);

await tx.signAndSend('//Alice', ({ status }) => {
  if (status.isInBlock) {
    console.log('Bridge XCM submitted in block', status.asInBlock.toString());
  }
});

Development Guides

1. Finality Relayer Checklist

Subscribe to bridgeWestendGrandpa.bestFinalized and bridgePolkadotBulletinGrandpa.bestFinalized storage changes.
Submit new proofs via BridgeGrandpa.submit_finality_proof extrinsics when headers advance by configured intervals.
Monitor pallet_bridge_relayers::Rewards to reconcile payments.

2. Message Relayer Operations

Watch bridgeWestendMessages.outboundLanes(laneId) for latest_generated_nonce vs latest_received_nonce.
Fetch Merkle lanes proof via bridge_messages_getProof before submitting to bridged chains.
Handle rejections by inspecting bridgeHub events: MessageDispatched and MessageRejected.

3. Observability & Alerting

Track BEEFY justifications with beefy_subscribeJustifications for Snowbridge health.
Use state_traceBlock on Bridge Hub to replay block execution when diagnosing bridge stalls.
Surface metrics such as MessageQueue.Processed events to confirm queue throughput.

Monitoring & Troubleshooting

Scenario	Diagnostic Steps	Resolution
Lane backpressure	Compare `latest_generated_nonce` and `latest_confirmed_nonce` on outbound lanes	Increase relayer frequency or investigate failed proofs
Proof rejected on target chain	Retrieve proof with `bridge_grandpa_getProof`/`bridge_messages_getProof` and re-run verification locally	Re-submit with corrected payload or wait for next finalized header
BEEFY stalled	Check `beefy_subscribeJustifications` stream and collator logs	Restart Snowbridge relayer or investigate validator availability

With Dwellir endpoints you get globally replicated infrastructure, WebSocket support for proof streaming, and archive access for rebuilding historical proofs.

Why Build on Bridge Hub?​

🔐 Trustless Finality​

🌉 Multi-Chain Connectors​

🧩 Specialized Pallets​

Quick Start with Bridge Hub​

🔗 RPC Endpoints

Installation & Setup​

Network Information​

Genesis Hash

Block Time

Native Token

Parachain ID

Available JSON-RPC Methods​

Core Substrate namespaces​

Bridge & BEEFY namespaces​

Bridge Protocols​

Snowbridge (Ethereum ↔ Polkadot)​

Kusama Bridge (Westend ↔ Polkadot)​

Bridge Bulletin​

XCM Integration​

Development Guides​

1. Finality Relayer Checklist​

2. Message Relayer Operations​

3. Observability & Alerting​

Monitoring & Troubleshooting​