Overview

These examples show the SDK shape across supported Quicknode products. They assume you already initialized the SDK as qn from the Quick Start.

Admin API

Use the Admin API client to inspect and manage account resources such as endpoints, teams, usage, billing, security, and rate limits.

Node.js

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const endpoints = await qn.admin.getEndpoints({
  limit: 20,
  sortBy: "created_at",
  sortDirection: "desc",
});

for (const endpoint of endpoints.data) {
  console.log(endpoint.id, endpoint.name, endpoint.status);
}

Python

import asyncio
from sdk import QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    endpoints = await qn.admin.get_endpoints(
        limit=20,
        sort_by="created_at",
        sort_direction="desc",
    )

    for endpoint in endpoints.data:
        print(endpoint.id, endpoint.name, endpoint.status)

asyncio.run(main())

Rust

use quicknode_sdk::{admin::GetEndpointsRequest, QuicknodeSdk};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let qn = QuicknodeSdk::from_env()?;

    let params = GetEndpointsRequest {
        limit: Some(20),
        sort_by: Some("created_at".to_string()),
        sort_direction: Some("desc".to_string()),
        ..Default::default()
    };
    let endpoints = qn.admin.get_endpoints(&params).await?;

    for endpoint in endpoints.data {
        println!("{} {} {}", endpoint.id, endpoint.name, endpoint.status);
    }

    Ok(())
}

Ruby

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

endpoints = qn.admin.get_endpoints(
    limit: 20,
    sort_by: "created_at",
    sort_direction: "desc",
)

endpoints["data"].each do |endpoint|
  puts "#{endpoint["id"]} #{endpoint["name"]} #{endpoint["status"]}"
end

For the full API surface, see the Admin API docs.

Streams

Use the Streams client to list, inspect, create, update, pause, activate, delete, and test Streams. The example below lists Streams, counts enabled Streams, and dry-runs a filter without changing account state.

Node.js

import { QuicknodeSdk, StreamDataset } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const streams = await qn.streams.listStreams({ limit: 10 });
console.log(`Streams: ${streams.pageInfo.total}`);

const enabled = await qn.streams.getEnabledCount();
console.log(`Enabled Streams: ${enabled.total}`);

const filterFunction = Buffer.from(`
function main(data) {
  return data;
}
`).toString("base64");

const result = await qn.streams.testFilter({
  network: "ethereum-mainnet",
  dataset: StreamDataset.Block,
  block: "17811625",
  filterFunction,
});

console.log(result.result);

Python

import asyncio
import base64
from sdk import QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    streams = await qn.streams.list_streams(limit=10)
    print(f"Streams: {streams.page_info.total}")

    enabled = await qn.streams.get_enabled_count()
    print(f"Enabled Streams: {enabled.total}")

    filter_function = base64.b64encode(
        b"function main(data) { return data; }"
    ).decode()

    result = await qn.streams.test_filter(
        network="ethereum-mainnet",
        dataset="block",
        block="17811625",
        filter_function=filter_function,
    )

    print(result.result)

asyncio.run(main())

Rust

use quicknode_sdk::{
    streams::{ListStreamsParams, StreamDataset, TestFilterParams},
    QuicknodeSdk,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let qn = QuicknodeSdk::from_env()?;

    let streams = qn
        .streams
        .list_streams(&ListStreamsParams {
            limit: Some(10),
            offset: Some(0),
            ..Default::default()
        })
        .await?;
    println!("Streams: {}", streams.page_info.total);

    let enabled = qn.streams.get_enabled_count(None).await?;
    println!("Enabled Streams: {}", enabled.total);

    let result = qn
        .streams
        .test_filter(&TestFilterParams {
            network: "ethereum-mainnet".to_string(),
            dataset: StreamDataset::Block,
            block: "17811625".to_string(),
            filter_function: Some(
                "ZnVuY3Rpb24gbWFpbihkYXRhKSB7IHJldHVybiBkYXRhOyB9".to_string(),
            ),
            filter_language: None,
            address_book_config: None,
        })
        .await?;

    println!("{}", result.result);
    Ok(())
}

Ruby

require "base64"
require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

streams = qn.streams.list_streams({ limit: 10, offset: 0 })
puts "Streams: #{streams["pageInfo"]["total"]}"

enabled = qn.streams.get_enabled_count({})
puts "Enabled Streams: #{enabled["total"]}"

filter_function = Base64.strict_encode64("function main(data) { return data; }")

result = qn.streams.test_filter(
    network: "ethereum-mainnet",
    dataset: "block",
    block: "17811625",
    filter_function: filter_function,
)

puts result["result"]

For destination options, supported datasets, and request details, see the Streams REST API docs.

Webhooks

Use the Webhooks client to list webhooks, inspect a webhook, create a webhook from a template, pause or activate delivery, and retrieve enabled counts. The example below is read-only.

Node.js

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const webhooks = await qn.webhooks.listWebhooks({
  limit: 10,
  offset: 0,
});

for (const webhook of webhooks.data) {
  console.log(webhook.id, webhook.name, webhook.status);
}

const enabled = await qn.webhooks.getEnabledCount();
console.log(`Enabled webhooks: ${enabled.total}`);

Python

import asyncio
from sdk import QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    webhooks = await qn.webhooks.list_webhooks(limit=10, offset=0)
    for webhook in webhooks.data:
        print(webhook.id, webhook.name, webhook.status)

    enabled = await qn.webhooks.get_enabled_count()
    print(f"Enabled webhooks: {enabled.total}")

asyncio.run(main())

Rust

use quicknode_sdk::{webhooks::GetWebhooksParams, QuicknodeSdk};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let qn = QuicknodeSdk::from_env()?;

    let webhooks = qn
        .webhooks
        .list_webhooks(&GetWebhooksParams {
            limit: Some(10),
            offset: Some(0),
        })
        .await?;

    for webhook in webhooks.data {
        println!("{} {} {}", webhook.id, webhook.name, webhook.status);
    }

    let enabled = qn.webhooks.get_enabled_count().await?;
    println!("Enabled webhooks: {}", enabled.total);

    Ok(())
}

Ruby

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

webhooks = qn.webhooks.list_webhooks({ limit: 10, offset: 0 })
webhooks["data"].each do |webhook|
  puts "#{webhook["id"]} #{webhook["name"]} #{webhook["status"]}"
end

enabled = qn.webhooks.get_enabled_count
puts "Enabled webhooks: #{enabled["total"]}"

For template behavior and destination configuration, see the Webhooks REST API docs.

Key-Value Store

Use the Key-Value Store client for simple persisted state. Sets store one string value per key. Lists store ordered string collections under one key.

Node.js

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const sets = await qn.kvstore.getSets({ limit: 10 });
console.log(`Sets: ${sets.data.length}`);

if (sets.data.length > 0) {
  const set = await qn.kvstore.getSet(sets.data[0].key);
  console.log(set.value);
}

const lists = await qn.kvstore.getLists({ limit: 10 });
console.log(`Lists: ${lists.data.keys.length}`);

Python

import asyncio
from sdk import QuicknodeSdk

async def main():
    qn = QuicknodeSdk.from_env()

    sets = await qn.kvstore.get_sets(limit=10)
    print(f"Sets: {len(sets.data)}")

    if len(sets.data) > 0:
        set_value = await qn.kvstore.get_set(sets.data[0].key)
        print(set_value.value)

    lists = await qn.kvstore.get_lists(limit=10)
    print(f"Lists: {len(lists.data.keys)}")

asyncio.run(main())

Rust

use quicknode_sdk::{
    kvstore::{GetListsParams, GetSetsParams},
    QuicknodeSdk,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let qn = QuicknodeSdk::from_env()?;

    let sets = qn
        .kvstore
        .get_sets(&GetSetsParams {
            limit: Some(10),
            cursor: None,
        })
        .await?;
    println!("Sets: {}", sets.data.len());

    if let Some(first_set) = sets.data.first() {
        let set = qn.kvstore.get_set(&first_set.key).await?;
        println!("{}", set.value);
    }

    let lists = qn
        .kvstore
        .get_lists(&GetListsParams {
            limit: Some(10),
            cursor: None,
        })
        .await?;
    println!("Lists: {}", lists.data.keys.len());

    Ok(())
}

Ruby

require "json"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_env

sets = qn.kvstore.get_sets({ limit: 10 })
puts "Sets: #{sets["data"].length}"

unless sets["data"].empty?
  set = qn.kvstore.get_set(key: sets["data"][0]["key"])
  puts set["value"]
end

lists = qn.kvstore.get_lists({ limit: 10 })
puts "Lists: #{lists["data"]["keys"].length}"

For all list and set operations, see the Key-Value Store REST API docs.

Agent workflow example

Agents can combine clients in one run. For example, a release automation agent can inspect endpoints, Streams, Webhooks, and Key-Value Store state before deciding what action to take.

import { QuicknodeSdk } from "@quicknode/sdk";

const qn = QuicknodeSdk.fromEnv();

const endpoints = await qn.admin.getEndpoints({ tagLabels: ["sdk-managed"] });
const streams = await qn.streams.listStreams({ limit: 10 });
const webhooks = await qn.webhooks.listWebhooks({ limit: 10 });
const sets = await qn.kvstore.getSets({ limit: 10 });

console.log({
  endpoints: endpoints.data.length,
  streams: streams.data.length,
  webhooks: webhooks.data.length,
  sets: sets.data.length,
});