Read Cairo contract state, follow events, and send account transactions with reliable, high-performance Starknet RPC infrastructure.
Connect to Starknet mainnet or Sepolia through one geo-balanced endpoint. Read contract state, follow native events, and submit account transactions without running your own Pathfinder node.
Query Cairo contract state, access historical data, inspect native transaction traces, and scale Starknet RPC workloads.
Scale high-volume RPC workloads with consistent performance, unlimited requests within your RPS tier, and predictable monthly costs.
Query historical Cairo contract state, storage, and blocks. Backfill Starknet data for analytics, portfolio reporting, and transaction reconciliation.
Inspect execution with starknet_traceTransaction and starknet_traceBlockTransactions. Diagnose reverted account transactions and investigate Cairo contract calls.
Read pool and lending-market state with starknet_call, estimate transaction fees, and follow contract events. Connect trading interfaces and DeFi backends with native Starknet APIs.
Explore Starknet APIs
Build around Starknet’s native account abstraction. Read account nonces, estimate fees, and submit account transactions with Starknet.js or Starknet.py.
Explore Starknet tooling
Retrieve paginated contract events with starknet_getEvents. Backfill blocks, transactions, and historical contract state for portfolio reporting, analytics, and reconciliation.
Explore Starknet methods
Inspect transaction execution and resource usage with starknet_simulateTransactions. Diagnose failures and estimate fees before broadcasting a signed account transaction.
Explore transaction simulation
Read token contract state, index transfer events, and track transaction receipts for BTC-backed assets on Starknet. Connect portfolio views, lending dashboards, and DeFi applications.
Get a Starknet RPC endpointRun Cairo applications, wallet backends, and indexers on isolated compute and storage. Deploy Pathfinder nodes on Starknet mainnet or Sepolia, with managed upgrades and node maintenance.
Select Starknet mainnet or Sepolia to see currently available node modes and monthly infrastructure pricing.
Save over 50% on our elite pay as you go plan
Chat on Telegram (opens in a new tab)Feedback from Starknet’s ecosystem and teams using Chainstack infrastructure across supported networks.
Chainstack’s robust infrastructure has significantly enhanced our ability to secure Web3 environments effectively.Chainstack has been crucial in enhancing Brave Wallet’s multi-chain functionality and UX.The Unlimited Node flat-fee model gives us cost predictability, and the performance is rock-solidChainstack is a leading provider of full-node services for blockchains.We’ve gone from weekly incidents to zero incidents.Build Cairo applications on geo-balanced Starknet endpoints. Scale with flat-fee Unlimited Node access or isolated Dedicated Nodes, while Chainstack handles deployment, upgrades, and node operations.
Get a Starknet endpointRun Pathfinder on Starknet mainnet or Sepolia with monitoring, automated updates, and self-healing operations. Supply an Ethereum Layer 1 RPC endpoint for the matching network and deploy on infrastructure you control.
Read the latest accepted Starknet block with starknet_blockNumber, using native JSON-RPC.
AI-ready infrastructure
Refer and earn
Ethereum
Hyperliquid
Solana
Arbitrum
BNB Smart Chain
Base
Polygon
TRON
Sui
Robinhood
SOC 2 Type II
ISO 27001
99.99%+ uptime
Learn more
View installation guidehttps://starknet-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID/rpc/v0_9Create a Starknet node and copy your HTTPS URL from Access and credentials. Replace YOUR_ENDPOINT_ID with your endpoint ID. These examples select API v0.9 explicitly with /rpc/v0_9.
curl --request POST \
--url https://starknet-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID/rpc/v0_9 \
--header 'Content-Type: application/json' \
--data '{
"jsonrpc": "2.0",
"id": 1,
"method": "starknet_blockNumber",
"params": []
}'The integer result is the latest accepted block number. Reading it does not send a transaction or spend STRK.
Start with free Starknet RPC for mainnet or Sepolia. Scale Cairo applications with archive data, native transaction tracing, and dedicated infrastructure.
Includes:
All Developer features, plus:
Add-ons and Dedicated Node infrastructure are billed separately.
Exceptional support on every paid planExplore native Starknet APIs, SDK setup, self-hosted nodes, and endpoint security.
Connect to versioned RPC endpoints and explore native API methods.
Read guide
Configure native SDKs and command-line tools for Starknet.
Read guide
Explore the release that added Starknet to Chainstack Self-Hosted.
Read guide
Restrict endpoint access by domain and IP address.
Read guide
Starknet RPC is the node API an application uses to read Starknet blockchain data, call Cairo smart contracts, and submit signed transactions. Starknet is an Ethereum Layer 2 validity rollup with native account abstraction. It uses starknet_* JSON-RPC methods rather than Ethereum’s eth_* methods. See the Starknet API reference.
Create a free Chainstack account, create a project, and deploy a Starknet Global Node on mainnet or Sepolia. Open Access and credentials to copy your endpoint URL. The Developer plan includes 3 million request units per month, up to 25 requests per second, and one node. No credit card is required.
Your authenticated mainnet URL follows https://starknet-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID; Sepolia uses https://starknet-sepolia.core.chainstack.com/YOUR_ENDPOINT_ID. Copy the complete URL from your node’s Access and credentials. Append /rpc/v0_9 to select JSON-RPC v0.9 explicitly, or /rpc/v0_10 for v0.10. Match the version to your SDK. See Starknet RPC version endpoints.
Starknet mainnet uses SN_MAIN, encoded as 0x534e5f4d41494e. Starknet Sepolia uses SN_SEPOLIA, encoded as 0x534e5f5345504f4c4941. Query starknet_chainId to check which network your endpoint serves. Starknet chain IDs are not Ethereum-style numeric network IDs. Check the official network information.
Use Starknet.js for JavaScript or TypeScript, Starknet.py for Python, and Starkli or Starknet Foundry for command-line development. You can also send JSON-RPC requests directly with cURL, JavaScript fetch, or Python requests. Ethereum libraries such as ethers.js are not substitutes for Starknet’s native SDKs. Follow the Starknet tooling guide.
Use starknet_call for read-only contract calls and starknet_getStorageAt for storage values. Retrieve contract events with starknet_getEvents, following continuation tokens when results are paginated. Use Starknet-native contract addresses, entry-point selectors, and calldata. See starknet_call examples and the supported methods.
Yes. Chainstack’s Starknet method reference lists native WebSocket subscriptions, including starknet_subscribeNewHeads, starknet_subscribeEvents, and transaction-status subscriptions. Copy your node’s WebSocket URL from Access and credentials. Use the native methods rather than Ethereum’s eth_subscribe or the removed pathfinder_subscribe methods. See Starknet method availability.
Yes. Use starknet_simulateTransactions to inspect execution before broadcasting and starknet_estimateFee to estimate transaction costs. Build payloads with a compatible Starknet SDK and RPC version. Current Starknet transactions use STRK-denominated fees, not Ethereum-style ETH gas settings. See the simulation reference and official fee documentation.
Yes. Archive access and transaction tracing are available from the Growth plan. Query historical contract state and inspect execution with starknet_traceTransaction or starknet_traceBlockTransactions. Trace calls consume 2 request units; archive classification depends on the method and requested block age. See Starknet request-unit rules and plan features.
Choose a Global Node for geo-balanced RPC access without running infrastructure. Add Unlimited Node from the Growth plan for flat-fee access within a selected RPS tier. Choose Dedicated Nodes from the Pro plan for isolated compute and storage, with infrastructure billed separately. Check current Starknet node configurations for available networks and modes.
Yes. Chainstack Self-Hosted supports Pathfinder nodes on Starknet mainnet and Sepolia. You supply an Ethereum Layer 1 RPC endpoint for the matching network: Ethereum mainnet for Starknet mainnet, or Ethereum Sepolia for Starknet Sepolia. Follow the installation guide and check supported clients and requirements.
Use the Starknet Foundation faucet to request test tokens for Starknet Sepolia, then connect your wallet and application to the same network. Test tokens have no monetary value and cannot pay mainnet fees. Chainstack’s faucet portal does not currently list Starknet.
Connect your application to Chainstack’s Starknet HTTPS endpoint using native starknet_* JSON-RPC methods. Read blocks and transactions, call Cairo contracts with starknet_call, retrieve events with starknet_getEvents, estimate fees, and simulate signed transaction payloads. Use Starknet.js or Starknet.py for native account and transaction handling. See the Starknet API reference and tooling guide.
Starknet mainnet uses chain ID SN_MAIN; Sepolia uses SN_SEPOLIA. Match the endpoint network and JSON-RPC version to your SDK. Chainstack documents /rpc/v0_9 and /rpc/v0_10 versioned endpoints; versions 0.6, 0.7, and 0.8 have been removed. Current transactions use STRK-denominated fees. Native WebSocket subscriptions include starknet_subscribeNewHeads and starknet_subscribeEvents. Check supported Starknet methods before integrating.
