The quickest way to start building on Fuel with Quicknode is by sending a GraphQL 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 other popular programming languages.

Get Your Fuel Endpoint

1

Ein Quicknode-Konto erstellen

Melde dich hier an, falls du das noch nicht getan hast.

2

Gehen Sie zu Ihrem Dashboard

Öffnen Sie das Endpunkte-Dashboard über das Menü in der linken Seitenleiste, um alle Ihre Blockchain-Endpunkte zu verwalten

3

Neuen Endpunkt erstellen

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

4

Kopieren Sie die URLs Ihres Anbieters

Halten Sie die HTTP-URL griffbereit. Sie werden sie in den folgenden Anfragen verwenden.

Erfahren Sie mehr über das Dashboard

Eine ausführliche Anleitung zur Nutzung des Quicknode-Dashboards finden Sie in unserem Leitfaden

Senden Sie Ihre erste Anfrage

Your endpoint is ready. Now, let's make your first call to the Fuel blockchain. We'll use the getChainName query, which retrieves the name of the blockchain network. Wählen Sie Ihre bevorzugte Sprache aus und befolgen Sie die nachstehenden Schritte, um Ihre erste Anfrage zu senden.

cURL

1

cURL-Installation überprüfen

Die meisten *nix-basierten Systeme unterstützen cURL standardmäßig. Öffnen Sie Ihr Terminal und überprüfen Sie die cURL-Version, indem Sie den folgenden Befehl ausführen:

curl --version

2

Get chain name

Retrieve the chain name using the getChainName query:

curl --location 'YOUR_QUICKNODE_ENDPOINT_URL/v1/graphql' \
--header 'Accept: application/json' \
--header 'Content-Type: application/json' \
--data '{"query": "{ chain { name } }"}'

Node.js

1

Richten Sie Ihr Projekt ein

Create a directory and initialize a Node.js project:

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

2

Create app.js

Create a file named app.js to call the getChainName query:

const https = require('https');

const data = JSON.stringify({
  "query": "{ chain { name } }"
});

const options = {
  hostname: '{your-endpoint-name}.quiknode.pro',
  path: '/{your-token}/v1/graphql',
  method: 'POST',
  headers: {
    'Accept': 'application/json',
    '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('Chain name:', result);
  });
});

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

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

3

Run

Execute your script:

Knoten app.js

Python

1

Richten Sie Ihr Projekt ein

Erstellen Sie ein neues Verzeichnis für Ihr Python-Projekt:

mkdir fuel-python-quickstart
cd fuel-python-quickstart

2

Eine virtuelle Umgebung erstellen und aktivieren

Erstellen Sie eine virtuelle Umgebung zur Verwaltung von Abhängigkeiten:

python3 -m venv venv
source venv/bin/activate

3

Installationsanfragen

Installieren Sie die Bibliothek „requests“ zum Absenden von HTTP-Anfragen:

pip install Requests

4

Erstellen Sie ein Python-Skript (app.py)

Create a Python file to call the getChainName query:

import requests
import json

url = "YOUR_QUICKNODE_ENDPOINT_URL/v1/graphql"

payload = json.dumps({
  "query": "{ chain { name } }"
})

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

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

print('Chain name:')
print(response.text)

5

Run

Execute your script:

python app.py

TypeScript

1

Richten Sie Ihr Projekt ein

Create a directory and initialize a TypeScript project:

mkdir fuel-ts-quickstart
cd fuel-ts-quickstart
npm init -y
npm install typescript @types/node tsx
npx tsc --init

2

Create app.ts

Create a file named app.ts to call the getChainName query:

import https from 'https';

interface GraphQLResponse {
  data: {
    chain: {
      name: string;
    };
  };
}

const data = JSON.stringify({
  query: "{ chain { name } }"
});

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

const req = https.request(options, (res) => {
  let result = '';
  res.on('data', (chunk: Buffer) => {
    result += chunk.toString();
  });
  res.on('end', () => {
    const response: GraphQLResponse = JSON.parse(result);
    console.log('Chain name:', response.data.chain.name);
  });
});

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

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

3

Run

Execute your script:

npx tsx app.ts

Apollo Client

1

Richten Sie Ihr Projekt ein

Create a directory and install Apollo Client:

mkdir fuel-apollo-quickstart
cd fuel-apollo-quickstart
npm init -y
npm install @apollo/client graphql cross-fetch

2

Create app.js

Create a file named app.js to query using Apollo Client:

const { ApolloClient, InMemoryCache, gql, HttpLink } = require('@apollo/client');
const fetch = require('cross-fetch');

const client = new ApolloClient({
  link: new HttpLink({
    uri: 'YOUR_QUICKNODE_ENDPOINT_URL/v1/graphql',
    fetch,
  }),
  cache: new InMemoryCache(),
});

const GET_CHAIN_NAME = gql`
  query GetChainName {
    chain {
      name
    }
  }
`;

client
  .query({
    query: GET_CHAIN_NAME,
  })
  .then((result) => {
    console.log('Chain name:', result.data.chain.name);
  })
  .catch((error) => {
    console.error('Error:', error);
  });

3

Run

Execute your script:

Knoten app.js

Ruby

1

Richten Sie Ihr Projekt ein

Erstellen Sie ein neues Verzeichnis für Ihr Ruby-Projekt:

mkdir fuel-ruby-quickstart
cd fuel-ruby-quickstart

2

Ruby-Installation überprüfen

Überprüfen Sie, ob Ruby auf Ihrem System installiert ist. Falls nicht, installieren Sie es unter https://ruby-lang.org:

ruby --version

3

Create a Ruby script (app.rb)

Create an app.rb file to call the getChainName query:

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

url = URI("YOUR_QUICKNODE_ENDPOINT_URL/v1/graphql")

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

request = Net::HTTP::Post.new(url)
request["Accept"] = "application/json"
request["Content-Type"] = "application/json"
request.body = JSON.dump({
  "query": "{ chain { name } }"
})

response = https.request(request)
result = JSON.parse(response.read_body)
puts "Chain name:"
puts result["data"]["chain"]["name"]

4

Führen Sie das Skript aus

Execute your Ruby script:

ruby app.rb

Wenn Sie mehr über das Absenden von API-Anfragen erfahren möchten, sehen Sie sich unsere Anleitungen und Beispiel-Apps an.

API-Übersicht

Discover Supported Fuel APIs, Networks, Chain Configurations, and compatible Quicknode Products

Anbieter-Endpunkte

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

Endgerätesicherheit

Sichern Sie Ihre Endpunkte mit Token-Authentifizierung, Ratenbegrenzung, Whitelisting, JWT und bewährten Sicherheitsverfahren

Marktplatz-Erweiterungen

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

Wir ❤️ Feedback!

Wenn Sie Anregungen oder Fragen zu dieser Dokumentation haben, teilen Sie uns diese bitte mit. Wir freuen uns auf Ihre Rückmeldung!