// Starknet

The Stack Starknet Builders Ship On

Connect to Starknet Mainnet and Sepolia Testnet with low-latency RPC, full archive data, debug and trace APIs, and real-time Streams. The complete Starknet data stack, managed from a single Quicknode dashboard.

Start building for freeContact sales
// Supported networksMainnetSepolia Testnet
// 99.99% uptime SLA17+ global regions
// Unified Starknet Stack

Mainnet, Testnet, Archive, and
WSS in One Dashboard.

Starknet builders need more than basic RPC. Quicknode runs the full surface: low-latency JSON-RPC, full archival history, trace, Pathfinder, and WSS subscriptions, all from one dashboard.

InterfaceStatus
MAINNETONLINE
TESTNETONLINE
ARCHIVEONLINE
WSSACTIVE
// Read & Subscribe

Data Access for Every Starknet Workload

Query and subscribe to Starknet data with low latency. From a single contract call to full historical blocks and state, you get the right interface for the job.

JSON-RPC over HTTPS and WSS on Mainnet and Sepolia Testnet
Contract calls, block and state reads, events, and transaction status
Archival access to full Starknet history with no pruning
Trace API for execution inspection
Pathfinder methods for proofs and enhanced reads
// Build & Ship

Native SDK Support

Land transactions on the same Quicknode account. The Starknet toolchain you already know works unchanged.

starknet.js and starknet.py supported out of the box
Token authentication, rate-limiting, JWT, and whitelisting on every endpoint
Full block, state, call, event, and transaction method coverage
Send invoke and declare transactions through low-latency, geo-routed endpoints

Enterprise-grade security and compliance built in

SOC 1
SOC 2 Type II
ISO 27001
// Every Starknet Data Pattern

The Full Data Suite.
Every Starknet Data Pattern.

Six ways to access Starknet data, from a single contract call to full archival history. Pick the interface, ship faster.

Starknet JSON-RPC

The full starknet_ JSON-RPC over HTTPS and WSS on Mainnet and Sepolia Testnet. Call contracts, read blocks and state, fetch events, check transaction status, and broadcast invoke transactions, with predictable rate limits.

Explore Core RPC API

Archive Access

Full historical Starknet state with no pruning. Read any block, state update, or event from genesis for indexing, analytics, and reconciliation.

Explore Archive Access

Trace API

Trace transaction execution on Starknet's STARK-based rollup. Inspect internal calls and debug Cairo contracts against live chain state.

Explore Core RPC API

Transaction Write API

Submit invoke, declare, and deploy-account transactions through the Starknet write API. Broadcast signed transactions from starknet.js or starknet.py against a private Quicknode endpoint.

Explore Core RPC API

Pathfinder RPC

Pathfinder node methods for proofs, transaction status, and enhanced Starknet data access on top of the core JSON-RPC. Use when you need Pathfinder-specific reads beyond the standard spec.

Explore Core RPC API

WebSocket Subscriptions

Subscribe to new blocks, events, and transaction status over WSS with Starknet and Pathfinder websocket methods. Push updates as they land, with no polling.

Explore Core RPC API
// Developer Experience

Native starknet_ RPC,
no rewrites.

Point starknet.js at a Quicknode Starknet endpoint and call contracts, read blocks, and send invoke transactions. The same starknet_ JSON-RPC you already use, on private low-latency infrastructure.

No rewrites

Point your existing Starknet codebase at a Quicknode endpoint and deploy. starknet.js, starknet.py, and your Cairo contracts carry over unchanged.

Same Starknet JSON-RPC methods

starknet_call, starknet_getEvents, starknet_getBlockWithTxs, and the Pathfinder extensions behave exactly as they do against a self-hosted node.

  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
  • 07
  • 08
  • 09
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
// Native Starknet RPC via starknet.js
import { RpcProvider } from "starknet";


const provider = new RpcProvider({
  nodeUrl: QUICKNODE_STARKNET_URL
});


// Read the latest block number
const block = await provider.getBlockNumber();


// Call a view function on a contract
const result = await provider.callContract({
  contractAddress: CONTRACT_ADDRESS,
  entrypoint: "balanceOf",
  calldata: [ACCOUNT_ADDRESS]
});
// Resources

Build on Starknet quicker.

Docs, guides, and runnable sample apps for every Starknet workload. Clone, customize, and ship.

// Docs

Starknet Documentation

Full reference for the Starknet Node, Trace, Write, and Pathfinder APIs, plus WebSocket subscriptions for blocks, events, and transaction status. Code examples in cURL, JavaScript, Python, and Ruby.

Read the docs
// Docs

Starknet RPC Quickstart

Create a Starknet endpoint, authenticate, and send your first starknet.js call against Mainnet or Sepolia.

Read the docs
// Sample Apps

Sample App Library

Runnable sample apps and starter kits across Quicknode-supported chains, including Starknet. Clone one and ship.

Browse sample apps
// Let's Build

Start where you are.

From your first Starknet endpoint to mission-critical production workloads, Quicknode scales with you. Get started in minutes.

// Developers

For builders who move fast.

Spin up your Starknet endpoint and ship. The free tier covers prototyping and small production loads, no credit card required.

Start building for free
// Enterprise

For teams scaling with confidence.

Dedicated Starknet infrastructure, contractual SLAs, priority support, and procurement-ready terms for wallets, exchanges, trading firms, and high-volume protocols.

Contact sales
"Quicknode has an impressive ecosystem of supported network and infrastructure providers. We are excited for the Chainlink platform to be included in the ecosystem."
Kate Lane, Strategic Partnerships @ Chainlink
// FAQ

Frequently Asked Questions

Still have unanswered questions? Reach out to support and the Quicknode team can help you find answers.