अवलोकन

Creates a new stream with a specified blockchain network, dataset type, destination, and optional filter function. Use this endpoint to programmatically set up real-time or historical blockchain data pipelines.

Key capabilities:

• Start from a specific block (backfills) or latest block (real-time streaming)
• Choose destination: webhook, S3, Azure Blob Storage, or PostgreSQL
• Attach a base64-encoded JavaScript filter to transform data before delivery
• Configure batch sizes, reorg detection, distance-from-tip, and elastic batching
• Set up multi-destination delivery with extra_destinations
• Receive email alerts on stream termination

Endpoint

Send a POST request to the following URL with your stream configuration in the request body.

POST https://api.quicknode.com/streams/rest/v1/streams

Request Parameters

Parameter	Type	Required	विवरण
नाम	डोरी	हाँ	A name for your stream
network	डोरी	हाँ	Blockchain network (see Supported Chains)
dataset	डोरी	हाँ	Dataset type (see Data Sources)
region	डोरी	हाँ	usa_east
dataset_batch_size	पूर्णांक	हाँ	Number of blocks to batch per delivery
elastic_batch_enabled	बूलियन	हाँ	Auto-adjust batch size to 1 near chain tip
destination	डोरी	हाँ	webhook, s3, azure, or postgres
destination_attributes	वस्तु	हाँ	Configuration for selected destination
स्थिति	डोरी	हाँ	active or paused
filter_function	डोरी	नहीं	Base64-encoded JavaScript filter function
start_range	पूर्णांक	नहीं	Starting block number (omit for latest)
end_range	पूर्णांक	नहीं	Ending block number (omit for continuous)
fix_block_reorgs	पूर्णांक	नहीं	1 to enable reorg detection and re-streaming
keep_distance_from_tip	पूर्णांक	नहीं	Blocks to stay behind chain tip
notification_email	डोरी	नहीं	Email for stream termination alerts
extra_destinations	सरणी	नहीं	Additional destinations (same structure as primary)

Destination Attributes

Configuration options vary based on the selected destination type. Select a tab below to view the required and optional attributes for each destination.

Webhook

Parameter	Type	Required	विवरण
url	डोरी	हाँ	Webhook endpoint URL
compression	डोरी	हाँ	none or gzip
max_retry	पूर्णांक	हाँ	Max retry attempts
retry_interval_sec	पूर्णांक	हाँ	Seconds between retries
post_timeout_sec	पूर्णांक	हाँ	Request timeout in seconds
headers	वस्तु	नहीं	Custom headers as key-value pairs
mtls	बूलियन	नहीं	Enable mutual TLS: Quicknode authenticates to your endpoint with its client certificate. Requires an HTTPS URL. See the Webhook destination page for server setup.
ssl_ca_pem	डोरी	नहीं	CA certificate (PEM) used to verify your endpoint's server certificate when it is signed by a private CA instead of a public one

For mTLS server configuration and how to download the Quicknode CA certificate, see Mutual TLS on the Webhook destination page.

S3

Parameter	Type	Required	विवरण
endpoint	डोरी	हाँ	S3 endpoint (e.g., s3.amazonaws.com)
bucket	डोरी	हाँ	Bucket name
secret_key	डोरी	हाँ	S3 secret key
access_key	डोरी	नहीं	S3 access key
object_prefix	डोरी	नहीं	Prefix for object keys
file_compression_type	डोरी	हाँ	none or gzip
file_type	डोरी	हाँ	.json
max_retry	पूर्णांक	हाँ	Max retry attempts
retry_interval_sec	पूर्णांक	हाँ	Seconds between retries
use_ssl	बूलियन	हाँ	Enable SSL

Azure

Parameter	Type	Required	विवरण
storage_account	डोरी	हाँ	Azure storage account name
container	डोरी	हाँ	Container name
sas_token	डोरी	हाँ	Shared Access Signature token
blob_prefix	डोरी	नहीं	Prefix for blob names
file_compression_type	डोरी	हाँ	none or gzip
file_type	डोरी	हाँ	.json
max_retry	पूर्णांक	हाँ	Max retry attempts
retry_interval_sec	पूर्णांक	हाँ	Seconds between retries

पोस्टग्रेएसक्यूएल

Parameter	Type	Required	विवरण
host	डोरी	हाँ	Database host
port	पूर्णांक	हाँ	Database port
username	डोरी	हाँ	Database username
password	डोरी	हाँ	Database password
table_name	डोरी	हाँ	Target table name
sslmode	डोरी	हाँ	require or disable
max_retry	पूर्णांक	हाँ	Max retry attempts
retry_interval_sec	पूर्णांक	हाँ	Seconds between retries

Example Request

cURL

curl -X POST "https://api.quicknode.com/streams/rest/v1/streams" \
  -H "accept: application/json" \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{
    "name": "My Stream",
    "network": "ethereum-mainnet",
    "dataset": "block",
    "filter_function": "ZnVuY3Rpb24gbWFpbihkYXRhKSB7Li4ufQ==",
    "region": "usa_east",
    "start_range": 100,
    "end_range": 200,
    "dataset_batch_size": 1,
    "destination": "webhook",
    "fix_block_reorgs": 0,
    "keep_distance_from_tip": 0,
    "elastic_batch_enabled": true,
    "destination_attributes": {
      "url": "https://webhook.site",
      "compression": "none",
      "headers": { "Authorization": "Bearer token" },
      "max_retry": 3,
      "retry_interval_sec": 1,
      "post_timeout_sec": 10,
      "mtls": true
    },
    "status": "active"
  }'

सीएलआई

qn stream create --name "My Stream" \
  --network ethereum-mainnet \
  --dataset block \
  --start 100 \
  --end 200 \
  --region usa_east \
  --webhook https://webhook.site \
  --status active \
  -o json

जावास्क्रिप्ट

const headers = new Headers()
headers.append('accept', 'application/json')
headers.append('Content-Type', 'application/json')
headers.append('x-api-key', 'YOUR_API_KEY')

const body = JSON.stringify({
  name: 'My Stream',
  network: 'ethereum-mainnet',
  dataset: 'block',
  filter_function: 'ZnVuY3Rpb24gbWFpbihkYXRhKSB7Li4ufQ==',
  region: 'usa_east',
  start_range: 100,
  end_range: 200,
  dataset_batch_size: 1,
  destination: 'webhook',
  fix_block_reorgs: 0,
  keep_distance_from_tip: 0,
  elastic_batch_enabled: true,
  destination_attributes: {
    url: 'https://webhook.site',
    compression: 'none',
    headers: { 'Authorization': 'Bearer token' },
    max_retry: 3,
    retry_interval_sec: 1,
    post_timeout_sec: 10,
    mtls: true
  },
  status: 'active'
})

fetch('https://api.quicknode.com/streams/rest/v1/streams', {
  method: 'POST',
  headers: headers,
  body: body
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error))

Python

import requests

url = "https://api.quicknode.com/streams/rest/v1/streams"

payload = {
    "name": "My Stream",
    "network": "ethereum-mainnet",
    "dataset": "block",
    "filter_function": "ZnVuY3Rpb24gbWFpbihkYXRhKSB7Li4ufQ==",
    "region": "usa_east",
    "start_range": 100,
    "end_range": 200,
    "dataset_batch_size": 1,
    "destination": "webhook",
    "fix_block_reorgs": 0,
    "keep_distance_from_tip": 0,
    "elastic_batch_enabled": True,
    "destination_attributes": {
        "url": "https://webhook.site",
        "compression": "none",
        "headers": { "Authorization": "Bearer token" },
        "max_retry": 3,
        "retry_interval_sec": 1,
        "post_timeout_sec": 10,
        "mtls": true
    },
    "status": "active"
}

headers = {
    "accept": "application/json",
    "Content-Type": "application/json",
    "x-api-key": "YOUR_API_KEY"
}

response = requests.post(url, headers=headers, json=payload)
print(response.json())

Ruby

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

url = URI("https://api.quicknode.com/streams/rest/v1/streams")
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["x-api-key"] = "YOUR_API_KEY"

request.body = {
  "name" => "My Stream",
  "network" => "ethereum-mainnet",
  "dataset" => "block",
  "filter_function" => "ZnVuY3Rpb24gbWFpbihkYXRhKSB7Li4ufQ==",
  "region" => "usa_east",
  "start_range" => 100,
  "end_range" => 200,
  "dataset_batch_size" => 1,
  "destination" => "webhook",
  "fix_block_reorgs" => 0,
  "keep_distance_from_tip" => 0,
  "elastic_batch_enabled" => true,
  "destination_attributes" => {
    "url" => "https://webhook.site",
    "compression" => "none",
    "headers" => { "Authorization" => "Bearer token" },
    "max_retry" => 3,
    "retry_interval_sec" => 1,
    "post_timeout_sec" => 10,
    "mtls" => true
  },
  "status" => "active"
}.to_json

response = https.request(request)
puts response.body

SDK (JS)

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

const qn = new QuicknodeSdk({ apiKey: "YOUR_API_KEY" })

const filterFunction = Buffer.from(`
function main(data) {
  return {
    hash: data.streamData.hash,
    number: parseInt(data.streamData.number, 16),
  }
}
`).toString("base64")

const stream = await qn.streams.createStream({
  name: "My Stream",
  network: "ethereum-mainnet",
  dataset: StreamDataset.Block,
  region: StreamRegion.UsaEast,
  startRange: 100,
  endRange: 200,
  datasetBatchSize: 1,
  elasticBatchEnabled: true,
  fixBlockReorgs: 0,
  keepDistanceFromTip: 0,
  filterFunction,
  status: StreamStatus.Active,
  destinationAttributes: {
    destination: "webhook",
    attributes: {
      url: "https://webhook.site",
      compression: "none",
      maxRetry: 3,
      retryIntervalSec: 1,
      postTimeoutSec: 10,
    },
  },
})

console.log(stream.id, stream.status)

SDK (Python)

import asyncio
import base64
from quicknode_sdk import QuicknodeSdk, SdkFullConfig, StreamWebhookDestination, WebhookAttributes

async def main():
    qn = QuicknodeSdk(SdkFullConfig(api_key="YOUR_API_KEY"))

    filter_function = base64.b64encode(b"""
function main(data) {
    return {
        hash: data.streamData.hash,
        number: parseInt(data.streamData.number, 16)
    };
}
""").decode()

    stream = await qn.streams.create_stream(
        name="My Stream",
        network="ethereum-mainnet",
        dataset="block",
        region="usa_east",
        start_range=100,
        end_range=200,
        dataset_batch_size=1,
        elastic_batch_enabled=True,
        fix_block_reorgs=0,
        keep_distance_from_tip=0,
        filter_function=filter_function,
        status="active",
        destination_attributes=StreamWebhookDestination(
            WebhookAttributes(
                url="https://webhook.site",
                max_retry=3,
                retry_interval_sec=1,
                post_timeout_sec=10,
                mtls=True,
                compression="none",
            )
        ),
    )

    print(stream.id, stream.status)

asyncio.run(main())

SDK (Ruby)

require "base64"
require "quicknode_sdk"

qn = QuicknodeSdk::SDK.from_config(api_key: "YOUR_API_KEY")

filter_function = Base64.strict_encode64(<<~JS)
  function main(data) {
    return {
      hash: data.streamData.hash,
      number: parseInt(data.streamData.number, 16)
    };
  }
JS

destination = QuicknodeSdk::DestinationAttributes.webhook(
  url: "https://webhook.site",
  max_retry: 3,
  retry_interval_sec: 1,
  post_timeout_sec: 10,
  mtls: true,
  compression: "none",
)

stream = qn.streams.create_stream(
  name: "My Stream",
  network: "ethereum-mainnet",
  dataset: "block",
  region: "usa_east",
  start_range: 100,
  end_range: 200,
  dataset_batch_size: 1,
  elastic_batch_enabled: true,
  fix_block_reorgs: 0,
  keep_distance_from_tip: 0,
  filter_function: filter_function,
  status: "active",
  destination_attributes: destination,
)

puts "#{stream["id"]} #{stream["status"]}"

SDK (Rust)

use quicknode_sdk::{
    streams::{
        CreateStreamParams, DestinationAttributes, StreamDataset, StreamRegion, StreamStatus,
        WebhookAttributes,
    },
    QuicknodeSdk,
    SdkFullConfig,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let qn = QuicknodeSdk::new(&SdkFullConfig::builder().api_key("YOUR_API_KEY").build())?;

    let filter_function = "ZnVuY3Rpb24gbWFpbihkYXRhKSB7Li4ufQ==".to_string();

    let params = CreateStreamParams::builder()
        .name("My Stream".to_string())
        .network("ethereum-mainnet".to_string())
        .dataset(StreamDataset::Block)
        .region(StreamRegion::UsaEast)
        .start_range(100)
        .end_range(200)
        .dataset_batch_size(1)
        .elastic_batch_enabled(true)
        .fix_block_reorgs(0)
        .keep_distance_from_tip(0)
        .filter_function(filter_function)
        .status(StreamStatus::Active)
        .destination_attributes(DestinationAttributes::Webhook(WebhookAttributes {
            url: "https://webhook.site".to_string(),
            compression: "none".to_string(),
            max_retry: 3,
            retry_interval_sec: 1,
            post_timeout_sec: 10,
            mtls: true,
            security_token: None,
        }))
        .build();

    let stream = qn.streams.create_stream(&params).await?;

    println!("{} {}", stream.id, stream.status);
    Ok(())
}

प्रतिक्रिया

On success, the API returns the created stream object with a unique ID, timestamps, and all configured parameters.

{
  "id": "f6ad6459-b5ad-4183-b370-1c1388e47e83",
  "name": "My Stream",
  "network": "ethereum-mainnet",
  "dataset": "block",
  "region": "usa_east",
  "filter_function": "ZnVuY3Rpb24gbWFpbihkYXRhKSB7Li4ufQ==",
  "start_range": 100,
  "end_range": 200,
  "dataset_batch_size": 1,
  "elastic_batch_enabled": true,
  "fix_block_reorgs": 0,
  "keep_distance_from_tip": 0,
  "destination": "webhook",
  "destination_attributes": {
    "url": "https://webhook.site",
    "compression": "none",
    "headers": { "Authorization": "Bearer token" },
    "max_retry": 3,
    "retry_interval_sec": 1,
    "post_timeout_sec": 10,
    "mtls": true,
    "security_token": "qn_xxxxxxxxxxxxxx"
  },
  "status": "active",
  "sequence": 0,
  "current_hash": null,
  "notification_email": null,
  "extra_destinations": [],
  "created_at": "2024-01-15T10:30:00Z",
  "updated_at": "2024-01-15T10:30:00Z"
}

Response Fields

Field	Type	विवरण
पहचान	डोरी	Unique stream identifier (UUID)
नाम	डोरी	Stream name
network	डोरी	Blockchain network
dataset	डोरी	Dataset type
region	डोरी	Deployment region
filter_function	डोरी	Base64-encoded filter function (if configured)
start_range	पूर्णांक	Starting block number
end_range	पूर्णांक	Ending block number (null for continuous)
dataset_batch_size	पूर्णांक	Number of blocks per batch
elastic_batch_enabled	बूलियन	Whether elastic batching is enabled
fix_block_reorgs	पूर्णांक	Reorg detection setting (1 = enabled)
keep_distance_from_tip	पूर्णांक	Blocks to stay behind chain tip
destination	डोरी	Destination type (webhook, s3, azure, postgres)
destination_attributes	वस्तु	Destination configuration (varies by type)
स्थिति	डोरी	Stream status (active or paused)
अनुक्रम	पूर्णांक	Last delivered block from the data range
current_hash	डोरी	Hash of the current block being processed
notification_email	डोरी	Email for stream termination alerts
extra_destinations	सरणी	Additional destinations (if configured)
created_at	डोरी	Stream creation timestamp (ISO 8601)
अपडेट किया गया_पर	डोरी	Last update timestamp (ISO 8601)

Response Destination Attributes

The destination_attributes object in the response varies based on the destination type. Select a tab below to view the fields returned for each destination.

Webhook

Field	Type	विवरण
url	डोरी	Webhook endpoint URL
compression	डोरी	Compression type (none or gzip)
headers	वस्तु	Custom headers (if configured)
max_retry	पूर्णांक	Maximum retry attempts
retry_interval_sec	पूर्णांक	Seconds between retries
post_timeout_sec	पूर्णांक	Request timeout in seconds
security_token	डोरी	Auto-generated token for validating webhook authenticity

S3

Field	Type	विवरण
endpoint	डोरी	S3 endpoint
bucket	डोरी	Bucket name
access_key	डोरी	S3 access key
object_prefix	डोरी	Prefix for object keys
file_compression_type	डोरी	Compression type (none or gzip)
file_type	डोरी	File format (.json)
max_retry	पूर्णांक	Maximum retry attempts
retry_interval_sec	पूर्णांक	Seconds between retries
use_ssl	बूलियन	SSL enabled status

Azure

Field	Type	विवरण
storage_account	डोरी	Azure storage account name
container	डोरी	Container name
blob_prefix	डोरी	Prefix for blob names
file_compression_type	डोरी	Compression type (none or gzip)
file_type	डोरी	File format (.json)
max_retry	पूर्णांक	Maximum retry attempts
retry_interval_sec	पूर्णांक	Seconds between retries

पोस्टग्रेएसक्यूएल

Field	Type	विवरण
host	डोरी	Database host
port	पूर्णांक	Database port
username	डोरी	Database username
table_name	डोरी	Target table name
sslmode	डोरी	SSL mode (require or disable)
max_retry	पूर्णांक	Maximum retry attempts
retry_interval_sec	पूर्णांक	Seconds between retries

note

Sensitive fields like secret_key (S3), sas_token (Azure), and password (PostgreSQL) are not returned in the response for security reasons.