What is the Starknet RPC URL?

The Starknet Mainnet RPC URL with BoltRPC is https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/starknet. Replace YOUR_API_KEY with your API key from dashboard.boltrpc.io. The network identifier is SN_MAIN.

What is the difference between Starknet and zkSync Era?

Both are ZK rollups settling to Ethereum. Starknet uses ZK-STARK proofs and runs on the Cairo VM - it is not EVM-compatible. zkSync Era uses ZK-SNARK proofs and is EVM-compatible with native account abstraction.

Cairo is Starknet's native smart contract language, designed to be provable by ZK-STARK proofs. Cairo is not Solidity-compatible. Developers building on Starknet write smart contracts in Cairo.

What Starknet RPC methods does BoltRPC support?

BoltRPC supports the full Starknet JSON-RPC specification including starknet_blockNumber, starknet_getBlockWithTxs, starknet_call, starknet_estimateFee, starknet_addInvokeTransaction, starknet_getEvents and all other standard Starknet methods.

Does BoltRPC support WebSocket for Starknet?

Yes. BoltRPC provides WebSocket endpoints for Starknet at wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/starknet.

What is the difference between STRK and ETH on Starknet?

Starknet uses two tokens: ETH for gas fees (bridged from Ethereum) and STRK, Starknet's native token. STRK was introduced as part of Starknet's decentralization roadmap. Most existing transactions use ETH for fees, but STRK fee payment is increasingly supported.

Starknet RPC Endpoint

Starknet's Cairo VM speaks its own JSON-RPC dialect. A dedicated endpoint with full starknet_ method coverage over HTTPS + WebSocket.

chain id · SN_MAINJSON-RPC 2.0WebSocket

Start free trial Contact sales

LIVE LATENCY

9ms

LIVE

gateway round-trip · sampled every second

IN PRODUCTION AT Chainlink

Your endpoint, ready in one line.

Drop this URL into your RPC client, HTTP library or wallet config. No SDK install required.

HTTPS

https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/starknet

WEBSOCKET

wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/starknet

Replace YOUR_API_KEY with your API key. Get a free key →

Pick your stack.

Copy-paste examples for the libraries you already use. Swap the API key, hit run.

import { RpcProvider } from "starknet";

const provider = new RpcProvider({
  nodeUrl: "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/starknet",
});

const block = await provider.getBlockNumber();

console.log("Latest block:", block);

import { RpcProvider, Contract } from "starknet";

const provider = new RpcProvider({
  nodeUrl: "https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/starknet",
});

// abi and address of the contract you want to read (an ERC-20 here)
const contract = new Contract({ abi, address, providerOrAccount: provider });
const balance = await contract.balanceOf(walletAddress);
console.log("Balance:", balance);

curl https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/starknet \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"starknet_blockNumber","params":[],"id":1}'

Connect your dApp, bot, or protocol to Starknet Mainnet with BoltRPC. Production-grade infrastructure for Cairo VM applications, built for teams that need a reliable provider as the Starknet ecosystem matures beyond the early adopter phase.

Chain at a Glance


Chain ID	SN_MAIN
Protocol	ZK Rollup (STARK proofs) on ETH
Block time	~2 s
Native token	STRK / ETH
Finality	STARK proof verification on Ethereum
EVM compatible	Partial (Cairo VM, not EVM)

What Starknet is Built For

Starknet is StarkWare’s STARK-based rollup, built for high-throughput provable computation. It uses the Cairo VM, a purpose-built execution environment designed to be efficiently provable by STARK proofs. Starknet is not EVM-compatible: smart contracts are written in Cairo, not Solidity. The RPC uses starknet_* methods instead of eth_*. The ecosystem includes Starknet-native DeFi protocols, NFT applications and developer tooling built around starknet.js and starknet-rs. Teams building on Starknet are typically developers who have committed to the Cairo programming model and are building applications that benefit from Starknet’s provable computation capabilities.

Developer Notes for Starknet

Starknet’s execution environment is fundamentally different from the EVM. Smart contracts are written in Cairo, a language designed to be efficiently provable by STARK proofs. Cairo’s type system and memory model are not compatible with Solidity and there is no automated transpiler from Solidity to Cairo. Teams moving to Starknet are committing to a full rewrite in Cairo, not a migration. The payoff is access to STARK proof security and the Cairo VM’s native provability features, which enable applications like on-chain gaming with verifiable computation.

The Starknet JSON-RPC specification uses starknet_* method prefixes throughout, meaning standard Ethereum libraries like ethers.js and viem will not work directly. The correct libraries are starknet.js for TypeScript/JavaScript, starknet-rs for Rust and cairo-rs for Python environments. All of these libraries are designed to work with the Starknet RPC spec and handle the Cairo-specific data types and transaction formats that Starknet requires.

Account abstraction on Starknet is native and mandatory. Every account on Starknet is a smart contract, there are no externally owned accounts in the Ethereum sense. This means every transaction is dispatched through an account contract and transaction signing uses the account contract’s own verification logic rather than a fixed ECDSA scheme. Standard Starknet wallets (Argent, Braavos) handle this automatically, but custom integrations need to account for the two-step declare-and-deploy account setup process.

Common Use Cases on Starknet

Cairo-native DeFi Starknet DEXes and lending protocols poll contract state with starknet_call and follow events with starknet_getEvents. The RPC surface is Starknet’s own. The endpoint serves all of it.

Wallets and account abstraction Every Starknet account is a contract, so wallets estimate fees, simulate and submit through starknet_estimateFee and starknet_addInvokeTransaction for every user action. starknet.js talks to the BoltRPC endpoint with a one-line provider change.

Provable computation and games On-chain games and verifiable compute apps generate bursty read traffic around each proof cycle. Dedicated capacity keeps state reads flowing while a batch settles to Ethereum.

Indexers and explorers Indexers replay starknet_getBlockWithTxs over long ranges and keep polling for new blocks. Published request-unit weights per method make the backfill a budget line instead of a surprise.

Built for teams that ship on Starknet.

Production-grade infrastructure for Cairo VM applications

Starknet's ecosystem is past early adopter stage. Production protocols running on Starknet need a provider that treats Starknet as a first-class supported chain, not an afterthought. BoltRPC provides dedicated Starknet infrastructure with the same reliability standards as its EVM chains.

ZK-STARK proof workloads demand more from infrastructure

Starknet's proving pipeline puts heavier demands on node infrastructure than standard EVM chains. ZK-STARK proof generation runs alongside standard JSON-RPC requests. BoltRPC's Starknet nodes are sized for production RPC volume alongside proof processing.

Full Starknet JSON-RPC specification

BoltRPC supports the full Starknet JSON-RPC specification including starknet_getBlockWithTxs, starknet_call, starknet_addInvokeTransaction and all standard methods. No partial implementation or missing endpoints.

Cairo ecosystem growth demands reliable access

Starknet's native smart contract language (Cairo) has a growing developer ecosystem. DeFi, NFT and gaming protocols on Starknet all require reliable RPC access. As the ecosystem grows, provider reliability becomes more critical.

Predictable RU pricing for Starknet-native call patterns

Starknet's starknet_call and starknet_estimateFee are the workhorse methods for Cairo contract interaction. Published per-method request-unit pricing means your call patterns do not create billing surprises as your application scales.

WebSocket for real-time Starknet monitoring

Subscribe to Starknet events and new blocks via WebSocket. Essential for applications that need to react to contract events and proof submissions in real time.

Full JSON-RPC coverage.

Every standard Starknet method you would expect. Archive-only methods are available on request for qualifying plans.

STANDARD6

starknet_blockNumberstarknet_callstarknet_getTransactionByHashstarknet_getTransactionReceiptstarknet_estimateFeestarknet_addInvokeTransaction

Starknet, explained.

Common questions about connecting to Starknet over BoltRPC.

Ask a question →Read the docs

: The Starknet Mainnet RPC URL with BoltRPC is https://endpoints.boltrpc.io/rpc/YOUR_API_KEY/starknet. Replace YOUR_API_KEY with your API key from dashboard.boltrpc.io. The network identifier is SN_MAIN.
: No. Starknet is not EVM-compatible. It runs on the Cairo VM (CairoVM), a completely different execution environment from the Ethereum Virtual Machine. Smart contracts on Starknet are written in Cairo, not Solidity. The RPC specification also differs, Starknet uses starknet_* methods instead of eth_* methods. You need starknet.js or starknet-rs to interact with Starknet, not ethers.js or viem.
: Both are ZK rollups settling to Ethereum, but they use different proof systems. Starknet uses ZK-STARK proofs and runs on the Cairo VM, it is not EVM-compatible. zkSync Era uses ZK-SNARK proofs and is EVM-compatible with native account abstraction. Starknet requires Cairo smart contracts; zkSync Era accepts Solidity. BoltRPC supports both Starknet and zkSync Era.
: Cairo is Starknet's native smart contract programming language. It is designed to be provable, Cairo programs can be efficiently verified by ZK-STARK proofs. Cairo is not Solidity-compatible. Developers building on Starknet write smart contracts in Cairo rather than porting existing Solidity contracts.
: BoltRPC supports the full Starknet JSON-RPC specification including: starknet_blockNumber, starknet_getBlockWithTxs, starknet_getTransactionByHash, starknet_getTransactionReceipt, starknet_call, starknet_estimateFee, starknet_addInvokeTransaction, starknet_addDeclareTransaction, starknet_getEvents and all other standard Starknet methods.
: Yes. BoltRPC provides WebSocket endpoints for Starknet at wss://endpoints.boltrpc.io/ws/YOUR_API_KEY/starknet. Use WebSocket for real-time Starknet event subscriptions and block monitoring.
: Starknet uses two tokens: ETH for gas fees (bridged from Ethereum) and STRK, Starknet's native token that can also be used for fees. STRK was introduced as part of Starknet's decentralization roadmap. Most existing Starknet transactions use ETH for fees, but STRK fee payment is increasingly supported by wallets and protocols.

Ship on Starknet this week.

An API key in under 60 seconds, Starknet plus 35+ other chains, and a team that answers when you write.

Start free trial View pricing