Moonriver RPC Guide: Endpoints, Methods, Canary Network Patterns (2026)

Moonriver is the canary network for Moonbeam, running on Kusama as a parachain. It is EVM-compatible and runs real economic activity with real MOVR tokens. Its purpose is to receive and validate new features, upgrades, integrations before they deploy to Moonbeam on Polkadot. For teams building for the Moonbeam ecosystem, Moonriver is where you build and test with real-world network conditions before promoting to production.

This guide covers public Moonriver RPC endpoints, multi-library connection examples, the Moonbeam/Moonriver deployment pattern, production considerations for canary network development.

For BoltRPC endpoint setup and MetaMask configuration, see the Moonriver chain page.

Moonriver as a Canary Network: What This Means for RPC

A canary network is not a testnet. Moonriver:

Has real economic value (MOVR token with market price)
Runs production-level DeFi protocols
Receives protocol upgrades before Moonbeam
Has its own parachain slot on Kusama (not Polkadot)

From an RPC perspective, the key differences from Moonbeam:

Property	Moonriver	Moonbeam
Chain ID	1285	1284
Network	Kusama parachain	Polkadot parachain
Native token	MOVR	GLMR
Purpose	Canary: new features first	Production
Block time	~12 s	~12 s
RPC methods	Same as Moonbeam	Same

Both chains expose identical EVM JSON-RPC interfaces plus Moonbeam-specific moon_* custom methods. Code written for Moonriver deploys to Moonbeam with only a chain ID and endpoint change.

Public Moonriver RPC Endpoints

Provider	HTTP Endpoint	WSS Endpoint	Notes
Moonbeam (official)	https://rpc.api.moonriver.moonbeam.network	wss://wss.api.moonriver.moonbeam.network	Official, rate limited
dRPC	https://moonriver.drpc.org	wss://moonriver.drpc.org	Public tier available
OnFinality	https://moonriver.api.onfinality.io/public	wss://moonriver.api.onfinality.io/public-ws	Free tier
Blast	https://moonriver.public.blastapi.io	none	Public tier

Chain ID: 1285 Native token: MOVR Block explorer: https://moonriver.moonscan.io

For production, use BoltRPC: https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY

Connecting to Moonriver

ethers.js

import { ethers } from "ethers";

// HTTP provider for Moonriver
const provider = new ethers.JsonRpcProvider(
  "https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY"
);

// Verify you're on Moonriver
const network = await provider.getNetwork();
console.log("Chain ID:", network.chainId); // 1285n, Moonriver

// Environment-based config for Moonriver / Moonbeam switching
const ENDPOINTS = {
  moonriver: "https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY",
  moonbeam:  "https://eu.endpoints.matrixed.link/rpc/moonbeam?auth=YOUR_KEY"
};

const env = process.env.CHAIN_ENV || "moonriver";
const activeProvider = new ethers.JsonRpcProvider(ENDPOINTS[env]);

// Read MOVR balance on Moonriver
const balance = await provider.getBalance("0xYourAddress");
console.log("MOVR balance:", ethers.formatEther(balance));

Web3.py

from web3 import Web3

# Connect to Moonriver
w3 = Web3(Web3.HTTPProvider(
    "https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY"
))

print("Connected:", w3.is_connected())
print("Chain ID:", w3.eth.chain_id)  # 1285 for Moonriver

# Guard against wrong network
assert w3.eth.chain_id == 1285, "Not connected to Moonriver"

# Get latest block
block = w3.eth.get_block("latest")
print("Block number:", block["number"])
print("Block time:", block["timestamp"])

# Get transaction count
tx_count = w3.eth.get_transaction_count("0xYourAddress")
print("Nonce:", tx_count)

curl

# Verify chain ID on Moonriver (should return 0x505 = 1285)
curl https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY \
  -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'

# Get block number
curl https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY \
  -X POST -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# moon_isBlockFinalized: works on Moonriver same as Moonbeam
curl https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY \
  -X POST -H "Content-Type: application/json" \
  --data '{
    "jsonrpc":"2.0",
    "method":"moon_isBlockFinalized",
    "params":["0xYourBlockHash"],
    "id":1
  }'

WebSocket subscription

import { ethers } from "ethers";

const wsProvider = new ethers.WebSocketProvider(
  "wss://eu.endpoints.matrixed.link/ws/moonriver?auth=YOUR_KEY"
);

// Monitor new blocks on Moonriver
wsProvider.on("block", async (blockNumber) => {
  const block = await wsProvider.getBlock(blockNumber);
  console.log("Moonriver block:", blockNumber, "Txs:", block.transactions.length);
});

// Filter contract events on Moonriver
const filter = {
  address: "0xYourMoonriverContract",
  topics: [ethers.id("Transfer(address,address,uint256)")],
  fromBlock: "latest"
};

wsProvider.on(filter, (log) => {
  console.log("Transfer on Moonriver:", log.transactionHash);
});

Example Moonriver RPC Methods

Moonriver supports all standard Ethereum JSON-RPC methods plus Moonbeam-specific custom methods. Code examples are for reference. Verify against the official Moonbeam documentation before production use.

Method	Purpose	Notes
`eth_chainId`	Returns 0x505 (1285)	Use to confirm Moonriver connection
`eth_blockNumber`	Get current block height	~12 second cadence
`eth_call`	Read contract state	Standard EVM
`eth_getLogs`	Fetch contract events	1,024 block max range on public nodes
`eth_sendRawTransaction`	Broadcast transaction	MOVR required for gas
`eth_getTransactionReceipt`	Get transaction result	Standard EVM receipt format
`moon_isBlockFinalized`	Check Kusama finality status	Moonriver-specific custom method
`moon_isTxFinalized`	Check transaction finality	Moonriver-specific custom method

Canary Network Deployment Workflow

The standard pattern for Moonbeam ecosystem development:

Step 1: Deploy to Moonriver. Moonriver runs the same EVM and Substrate runtime as Moonbeam. Deploy your contracts with chain ID 1285 and test all functionality including any XCM integrations.

Step 2: Test with real conditions. Moonriver has real DeFi protocols, real liquidity, real network activity. Testing here is meaningfully more realistic than a testnet. Check your contracts against production-like state.

Step 3: Validate custom method behavior. If your application uses moon_isBlockFinalized or XCM precompiles, validate the behavior on Moonriver. Upgrade schedules may differ between Moonriver and Moonbeam, so newly added precompile addresses or method signatures should be confirmed on both.

Step 4: Promote to Moonbeam. Change your endpoint from Moonriver to Moonbeam and update chain ID from 1285 to 1284. Deploy the same contract code (contract addresses will differ but logic is identical).

// Config-driven environment switching
const config = {
  moonriver: {
    chainId: 1285,
    rpc: "https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY",
    wss: "wss://eu.endpoints.matrixed.link/ws/moonriver?auth=YOUR_KEY",
    explorer: "https://moonriver.moonscan.io"
  },
  moonbeam: {
    chainId: 1284,
    rpc: "https://eu.endpoints.matrixed.link/rpc/moonbeam?auth=YOUR_KEY",
    wss: "wss://eu.endpoints.matrixed.link/ws/moonbeam?auth=YOUR_KEY",
    explorer: "https://moonscan.io"
  }
};

const active = config[process.env.DEPLOY_ENV || "moonriver"];
const provider = new ethers.JsonRpcProvider(active.rpc);

// Verify correct network before any operations
const network = await provider.getNetwork();
if (Number(network.chainId) !== active.chainId) {
  throw new Error(`Wrong network: expected ${active.chainId}, got ${network.chainId}`);
}

Kusama vs Polkadot: What Changes for RPC

Moonriver runs on Kusama (Polkadot’s canary relay chain) and Moonbeam runs on Polkadot. From an RPC standpoint, the behavior is nearly identical. There are some operational differences to be aware of:

Upgrade frequency: Kusama is upgraded more frequently than Polkadot. Moonriver may receive runtime upgrades more often than Moonbeam. This can occasionally cause temporary behavior changes after an upgrade window.

Finality timing: Kusama’s Relay Chain finalizes blocks on a similar cadence to Polkadot (every 12 seconds). moon_isBlockFinalized has the same usage on Moonriver as on Moonbeam.

Block times are identical: Both run at approximately 12-second block times, tied to their respective relay chain slot cadences.

Production Issues on Moonriver

Chain ID confusion. The most common error when working with both Moonriver and Moonbeam is connecting to the wrong chain. Always assert chain ID in your connection initialization code. A transaction signed for chain ID 1285 (Moonriver) will fail on chain ID 1284 (Moonbeam) and vice versa.

MOVR for gas on Moonriver. Moonriver uses MOVR for gas fees. If you are deploying contracts for testing, ensure your deployer wallet has MOVR, not GLMR, which is the Moonbeam token. Both are available on exchanges but are distinct assets.

Public endpoint rate limits. Moonriver’s official public endpoint has undocumented rate limits. During active development with frequent contract calls, you can exhaust these quickly. Use a dedicated provider for sustained development work.

XCM precompile addresses are the same. Moonriver uses the same precompile addresses as Moonbeam for XCM functionality. This makes environment switching straightforward: no address updates needed for precompile interactions.

Choosing a Moonriver RPC Provider

Consideration	What to Look For
Moonbeam + Moonriver support	Single provider for both simplifies env management
Custom method support	`moon_isBlockFinalized` required for finality-sensitive apps
WebSocket reliability	Parachain event subscriptions need stable connections
Consistent pricing	Canary network work should not cost more than production

For dedicated Moonriver RPC (and Moonbeam on the same provider): BoltRPC Moonriver endpoint.

Moonriver RPC FAQ

What is the Moonriver RPC endpoint? Official public HTTP: https://rpc.api.moonriver.moonbeam.network. WSS: wss://wss.api.moonriver.moonbeam.network. For production, BoltRPC provides a dedicated endpoint at https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY. Chain ID is 1285.

What is the difference between Moonriver and Moonbeam? Moonriver is the canary network for Moonbeam. It runs on Kusama (chain ID 1285) and receives upgrades and new features before Moonbeam on Polkadot (chain ID 1284). Moonriver has real economic value (MOVR token) and real DeFi activity. It is not a testnet, but it is where new features appear first.

Is Moonriver a testnet? No. Moonriver runs real economic activity with real MOVR tokens that have market value. It is a canary network, meaning it receives protocol upgrades before Moonbeam for real-world validation. Think of it as a production environment for experimental features.

What chain ID is Moonriver? Moonriver chain ID is 1285 (0x505 in hex). Moonbeam chain ID is 1284 (0x504 in hex). Always verify chain ID when switching between environments.

Do the same RPC methods work on Moonriver and Moonbeam? Yes. Moonriver and Moonbeam share the same EVM runtime and support the same methods including custom moon_* methods. Occasionally, a newly added method may appear on Moonriver before it reaches Moonbeam due to the upgrade sequencing.

Can I use the same smart contract ABI on both Moonriver and Moonbeam? Yes. ABIs and bytecode are identical. Only the deployed contract addresses differ between networks. The underlying EVM runtime is the same on both chains.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the Moonriver RPC endpoint?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Official public HTTP: https://rpc.api.moonriver.moonbeam.network. WSS: wss://wss.api.moonriver.moonbeam.network. For production, BoltRPC provides https://eu.endpoints.matrixed.link/rpc/moonriver?auth=YOUR_KEY. Chain ID is 1285."
      }
    },
    {
      "@type": "Question",
      "name": "What is the difference between Moonriver and Moonbeam?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Moonriver is the canary network for Moonbeam. It runs on Kusama (chain ID 1285) and receives upgrades before Moonbeam on Polkadot (chain ID 1284). Moonriver has real economic value and real DeFi activity. It is not a testnet."
      }
    },
    {
      "@type": "Question",
      "name": "Is Moonriver a testnet?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. Moonriver runs real economic activity with real MOVR tokens that have market value. It is a canary network that receives protocol upgrades before Moonbeam for real-world validation."
      }
    },
    {
      "@type": "Question",
      "name": "What chain ID is Moonriver?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Moonriver chain ID is 1285 (0x505 in hex). Moonbeam chain ID is 1284 (0x504 in hex). Always verify chain ID when switching between environments."
      }
    },
    {
      "@type": "Question",
      "name": "Do the same RPC methods work on Moonriver and Moonbeam?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. Moonriver and Moonbeam share the same EVM runtime and support the same methods including custom moon_* methods. Occasionally a newly added method appears on Moonriver before reaching Moonbeam due to upgrade sequencing."
      }
    }
  ]
}
</script>

Moonriver RPC Guide: Endpoints, Methods, Code Examples 2026