Solana Beta is now live
Try it free
Starknet's Cairo VM speaks its own JSON-RPC dialect. A dedicated endpoint with full starknet_ method coverage over HTTPS + WebSocket.
latency
Quick connect
Drop this URL into your RPC client, HTTP library or wallet config. No SDK install required.
https://eu.endpoints.matrixed.link/rpc/starknet?auth=YOUR_API_KEY wss://eu.endpoints.matrixed.link/ws/starknet?auth=YOUR_API_KEY
Replace YOUR_API_KEY with your API key.
Get a free key →
Connect
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://eu.endpoints.matrixed.link/rpc/starknet?auth=YOUR_API_KEY",
});
const block = await provider.getBlockNumber();About Starknet
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 ID | SN_MAIN |
| Protocol | ZK Rollup (STARK proofs) on ETH |
| Block time | ~6 s |
| Native token | STRK / ETH |
| Finality | STARK proof verification on Ethereum |
| EVM compatible | Partial (Cairo VM, not EVM) |
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, and 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.
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.
Why BoltRPC
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.
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.
BoltRPC supports the full Starknet JSON-RPC specification including starknet_getBlock, starknet_call, starknet_addInvokeTransaction, and all standard methods. No partial implementation or missing endpoints.
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.
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.
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.
FAQ
Common questions about connecting to Starknet over BoltRPC.
Get started
One endpoint format, 20+ networks, no SDK. Drop our URL into the client you already use and your integration is done.
No credit card required. · 14-day trial on any tier.