The quickest way to start building on Starknet with QuickNode is by sending a JSON-RPC request to your endpoint. In this quickstart, you’ll create an endpoint, copy its provider URL, and make your first request. Code samples are available in cURL as well as popular SDKs and programming languages.

Get Your Starknet Endpoint

1

Create a QuickNode account

Sign up here if you haven't already.

2

Go to your dashboard

Open the Endpoints dashboard from the left sidebar menu to manage all your blockchain endpoints

3

Create a new endpoint

Click Create an Endpoint in the top-right corner, select Starknet as your blockchain, then select your preferred network

4

Copy your provider URLs

Keep the HTTP URL handy. You'll use it in your requests below.

Learn More about the Dashboard

For a detailed walkthrough of the QuickNode dashboard, check out our guide

Send Your First Request

Your endpoint is ready. Now, let's make your first call to the Starknet blockchain. We'll use the starknet_blockNumber method, which returns the latest block number. Select your preferred language or SDK and follow the steps below to send your first request.

cURL

1

Check cURL installation

Most *nix based systems have cURL support out of the box. Open your terminal and check the cURL version by running the command below:

curl --version

2

Send a JSON-RPC request

In your terminal, copy and paste the following cURL command to retrieve the latest block number:

curl -X POST YOUR_QUICKNODE_ENDPOINT_URL/rpc/v0_8 \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","method":"starknet_blockNumber","params":[],"id":1}'

3

Sample Response

{
  "id": 1,
  "jsonrpc": "2.0",
  "result": 2004149
}

JavaScript

1

Set up your project

Create a new directory and initialize a Node.js project:

mkdir starknet-js-quickstart
cd starknet-js-quickstart
npm init -y

2

Create a JavaScript file (app.js)

Add the code into your JavaScript file and execute the file in your terminal with the `node fileName.js` to retrieve the current block number.

const https = require('https');

const data = JSON.stringify({
  "id": 1,
  "jsonrpc": "2.0",
  "method": "starknet_blockNumber",
  "params": []
});

const options = {
  hostname: '{your-endpoint-name}.quiknode.pro',
  path: '/{your-token}/rpc/v0_8',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': data.length
  }
};

const req = https.request(options, (res) => {
  let result = '';
  res.on('data', (chunk) => {
    result += chunk;
  });
  res.on('end', () => {
    console.log(result);
  });
});

req.on('error', (error) => {
  console.error('Error:', error);
});

req.write(data);
req.end();

3

Run the script

Execute your JavaScript script:

node app.js

Python

1

Set up your project

Create a new directory for your Python project:

mkdir starknet-python-quickstart
cd starknet-python-quickstart

2

Create and activate a virtual environment

Create a virtual environment to manage dependencies:

python3 -m venv venv
source venv/bin/activate

3

Install requests

Install the requests library for making HTTP requests:

pip install requests

4

Create a Python script (app.py)

To run the Python code below, add the code to a file and execute it with the `python file.py` command in your terminal window.

import requests
import json

url = "YOUR_QUICKNODE_ENDPOINT_URL/rpc/v0_8"

payload = json.dumps({
  "id": 1,
  "jsonrpc": "2.0",
  "method": "starknet_blockNumber",
  "params": []
})

headers = {
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

5

Run the script

Execute your Python script:

python app.py

Ruby

1

Set up your project

Create a new directory for your Ruby project:

mkdir starknet-ruby-quickstart
cd starknet-ruby-quickstart

2

Check Ruby installation

Verify Ruby is installed on your system. If not, install it from https://ruby-lang.org:

ruby --version

3

Create a Ruby script (main.rb)

Create a main.rb file with the following code:

require "uri"
require "json"
require "net/http"

url = URI("YOUR_QUICKNODE_ENDPOINT_URL/rpc/v0_8")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "id": 1,
  "jsonrpc": "2.0",
  "method": "starknet_blockNumber",
  "params": []
})

response = https.request(request)
result = JSON.parse(response.read_body)

puts "Block number: #{result["result"]}"

4

Run the script

Execute your Ruby script to see the current block number:

ruby main.rb

If you want to continue learning about making API requests, check out our guides and sample apps.

API Overview

Discover Supported Starknet APIs, Networks, Chain Configurations, and compatible QuickNode Products

Provider Endpoints

Learn how to set up and configure your Starknet RPC endpoints for development and production use

Endpoint Security

Secure your endpoints with Token Authentication, Rate-limiting, Whitelisting, JWT and best security practices

Error Reference

Reference document for common Starknet RPC error codes and troubleshooting tips

Marketplace Add-ons

Discover powerful add-ons and extensions to enhance your Starknet development workflow

We ❤️ Feedback!

If you have any feedback or questions about this documentation, let us know. We'd love to hear from you!