🟦 Node

In the vast RSS3 Network, the RSS3 Node delivers Open Information with efficiency, it is a steadfast cruiser in the byte-filled sea.

What is an RSS3 Node

An RSS3 Node, also known as an RSS3 Node, is responsible for indexing, transforming, storing, and ultimately serving Open Information to the end users.

The operation of an RSS Node is permissionless and is subject to a set of requirements set by the Network.

The code base is publicly available as open source on GitHub.


This guide provides instructions for deploying the RSS3 Node using containerized solutions including Docker and Kubernetes. It is assumed that the user has a basic understanding of terminal commands and containerization concepts.

The guide is opinionated towards a containerized deployment solution, the source code is available on GitHub if one prefers an alternative deployment method.

It's important to note that while the Node itself is production-ready, the deployment methods we outline here may not be universally applicable in all environments. Adaptation of these methods may be necessary to fit the specific requirements of your own setup.


  • Basic command line proficiency
  • Have Docker installed
  • Have your Node registered on the VSL

Hardware Requirements

  • Alpha Mainnet: practically any hardware (yes, Raspberry Pis included) can run an Alpha RSS3 Node, as it does not commission any indexers at this phase.
  • Beta Mainnet: depending on the indexing coverage, the hardware requirements may vary. We recommend a minimal configuration of 8 Core, 16 GB RAM, 500 GB SSD to operate an entry-level RSS3 Node.
  • Production Mainnet: we highly recommend a minimal configuration of 16 Core, 64 GB RAM, 500 GB SSD * 3 to operate an advanced RSS3 Node to boost your work rate.

Local LLMs

Running local LLMs requires additional resources (GPUs). We will release relevant documentation and a deployment guide soon.

Deploy via docker-compose

A configuration file is required for deploying your RSS3 Node.


We strongly recommend that everyone use the configuration generator to minimize the risk of manual errors.

  1. During your Node registration https://explorer.rss3.io/nodes/register, follow the steps and generate a config.yaml, and download it.
  2. In the same directory as your config.yaml, download the automated deployment script by executing the following command:
curl -s https://raw.githubusercontent.com/RSS3-Network/Node-Automated-Deployer/main/automated_deploy.sh | sudo bash

🎉 And you are done!

A sample config file looks like:

# `environment` is the environment of the Node, possible values are `development` and `production`.
# DO NOT change this value except for local debugging purposes.
environment: production
# `type` is the type of the Node, possible values are `alpha`, `beta`, and `production`.
# DO NOT change this value.
type: beta

# `discovery` is used for Node discovery and verification.
    # `evm_address` is the wallet address used during your registration on the RSS3 Explorer.
    evm_address: 0x...address
    # The `signature` obtained during registration, it will be used to verify your ownership of this Node.
    # You MUST NOT share the signature with anyone.
    signature: 0x...signature
    # `endpoint` is how how Global Indexers access your Node.
    # You can use a domain or an IP address.
    endpoint: https://your.node.com
    # If your Node is registered on the VSL Testnet, use https://gi.rss3.dev.
    # Otherwise, DO NOT change this value.
    global_indexer_endpoint: https://gi.rss3.io

# Database configuration
  driver: cockroachdb
  partition: true
  uri: postgres://root@localhost:26257/defaultdb

# Deploying a redis will significantly improve the indexing performance of some workers.
    - localhost:6379
  disable_cache: true
    enabled: false
    ca_file: /path/to/ca.crt
    cert_file: /path/to/client.crt
    key_file: /path/to/client.key
    insecure_skip_verify: false

# `stream` enables message streaming for the Node.
# This feature is currently under development and should be disabled.
  enable: false

# `observability` tools used to monitor and inspect the Node.
# This feature is for advanced users only.
# DO NOT modify the values unless you know what you are doing.
      enable: true
      enable: true
      endpoint: localhost:4318
      insecure: true

# `endpoints` are data access points for Workers.
# Endpoints defined here can be referenced in the configuration below.
# For example,
# - Blockchain networks require RPC endpoints,
# - Arweave requires a gateway endpoint,
# - Farcaster requires a Hubble.
    # `http2_disabled` is used to disable HTTP/2 when the endpoint does not support it.
    http2_disabled: true
    # You can define any HTTP headers that may be required by the endpoint.
    # For example, you can use the `x-api-key`, or `any-header`.
    x-api-key: apikey
    url: https://rpc.rss3.io
    url: https://arweave.net

# `component` is used to split different types of networks.
  # `rss` network type includes workers indexing data in RSS format.
    - network: rss
      endpoint: https://your.rsshub.com/
  # `decentralized` network type includes workers indexing data from decentralized networks such as blockchain networks, Arweave, etc.
    # Each configuration here initializes a worker.
    # `id` is the unique identifier
    - id: vsl-core
      # `network` is the network that the worker is indexing from.
      network: vsl
      # `endpoint` is the data access endpoint used by the worker.
      # You can reference the endpoint defined above in the `endpoints` section.
      # You can also use a direct URL, such as `https://rpc.rss3.io`.
      endpoint: vsl
      # `worker` is the actual worker that processes the data.
      # You can find the list of available workers here: https://github.com/RSS3-Network/Node/blob/develop/README.md#supported-networks-and-workers.
      worker: core
    - id: arweave-mirror
      network: arweave
      endpoint: arweave
      worker: mirror
      # `ipfs_gateways` is used to specify the IPFS gateways used by the worker.
      # Supplying multiple gateways may improve the indexing performance and reliability.
        - https://ipfs.io
        - https://cloudflare-ipfs.com
        # `concurrent_block_requests` is used to specify the number of concurrent block requests.
        concurrent_block_requests: 2

Deploy via Kubernetes

For those with strong Kubernetes knowledge.


  • Have kind installed
  • Have Helm installed

Create a Kubernetes cluster via kind

Create our Kubernetes cluster with the following command

kind create cluster --name node

Depoly via using RSS3's Helm Chart

Since Helm uses a chart file for deployment. We can easily deploy an RSS3 Node by using the chart files provided.

helm repo add rss3 https://rss3-network.github.io/helm-charts
helm repo update

Get Help

In case you run into any issues, please reach out to us on Discord .


This guide provides basic instructions for deploying an RSS3 Node in containerized environments. For more advanced configurations, refer to the respective Docker or Kubernetes documentation.

This guide adopts an opinionated stance in favor of containerized deployment. We advocate for this approach due to its benefits in ensuring consistency and scalability, promoting ease of portability across various environments. However, we appreciate the diverse preferences and needs within our community, for those who wish to compile and run the application locally, the source code is available on GitHub.