SOC 2 Type II (s'ouvre dans un nouvel onglet)
ISO 27001 (s'ouvre dans un nouvel onglet)
Disponibilité supérieure à 99,99 % (s'ouvre dans un nouvel onglet)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.
Faites évoluer vos charges de travail RPC à haut volume tout en bénéficiant de performances constantes, d'un nombre illimité de requêtes au sein de votre niveau « RPS » et de coûts mensuels prévisibles.
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.
Feedback from Starknet’s ecosystem and teams using Chainstack infrastructure across supported networks.
ChainstackSon infrastructure robuste a considérablement renforcé notre capacité à sécuriser efficacement les environnements Web3.Chainstack a joué un rôle essentiel dans l'amélioration des fonctionnalités multi-chaînes et de l'expérience utilisateur (UX) de Brave Wallet.Le modèle de forfait « Unlimited » d'Node nous offre une prévisibilité des coûts, et ses performances sont d'une fiabilité à toute épreuve.Chainstack is a leading provider of full-node services for blockchains.Nous sommes passés de plusieurs incidents par semaine à zéro incident.
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.
Infrastructure compatible avec l'IA
Parrainez et gagnez
Ethereum
Hyperliquid
Solana
Arbitrum
BNB Smart Chain
Base
Polygon
TRON
Sui
Robinhood
En savoir plus
Consulter le guide d'installationhttps://starknet-mainnet.core.chainstack.com/YOUR_ENDPOINT_ID/rpc/v0_9Create a Starknet node and copy your HTTPS URL from Accès et identifiants. Remplacer 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.
Consulter la référence des méthodes (s'ouvre dans un nouvel onglet)
Start with free Starknet RPC for mainnet or Sepolia. Scale Cairo applications with archive data, native transaction tracing, and dedicated infrastructure.
Comprend :
Toutes les fonctionnalités destinées aux développeurs, ainsi que :
Les modules complémentaires et l'infrastructure dédiée d'Node sont facturés séparément.
Une assistance exceptionnelle pour toutes les formules payantesÉconomisez plus de 50 % sur notre formule haut de gamme « Pay-as-you-go »
Discuter sur Telegram (s'ouvre dans un nouvel onglet)Explore native Starknet APIs, SDK setup, self-hosted nodes, and endpoint security.
Connect to versioned RPC endpoints and explore native API methods.
Lire le guide
Configure native SDKs and command-line tools for Starknet.
Lire le guide
Explore the release that added Starknet to Chainstack Self-Hosted.
Lire le guide
Limiter l'accès aux terminaux en fonction du domaine et de l'adresse IP.
Lire le 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. Copiez l'URL complète depuis votre node’s Accès et identifiants. 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 informations officielles du réseau.
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.
Utilisation 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 et le méthodes prises en charge.
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 Accès et identifiants. Use the native methods rather than Ethereum’s eth_subscribe or the removed pathfinder_subscribe methods. See Starknet method availability.
Oui. Utilisez 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 et 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 et caractéristiques du forfait.
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 et guide d'outillage.
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 et /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 et starknet_subscribeEvents. Vérifier supported Starknet methods before integrating.
