There’s a particular kind of thrill that comes from contributing directly to decentralized infrastructure. Especially when it doesn’t involve deploying smart contracts or shipping a DAO meme coin. If you’re a builder, tinkerer, or simply curious about Web3, setting up a Pocket Network (Pocket) node is one of the most accessible and meaningful ways to connect with the future of decentralized data.
In this blog, we’re going to walk you through the simple, script-based method for launching your first Pocket node—but before we even touch a terminal, let’s talk about what a Pocket node is, why it matters, and what kind of magic you’re enabling by running one.
What is Pocket Network (and Why Should You Care?)
Pocket Network is a decentralized infrastructure protocol built to provide scalable, reliable, and censorship-resistant access to open data. At its core, it enables developers to access blockchain data (and now, with the Shannon upgrade, any open API or service) through a permissionless network of globally distributed nodes. Think of it as the Web3 alternative to centralized RPC providers like Infura, Alchemy, or QuickNode—but without a single point of failure.
Originally launched as a decentralized RPC network for servicing blockchain relays, Pocket has evolved into a more general-purpose decentralized data layer. With the recent Shannon upgrade, it supports not just blockchains like Ethereum and Polygon, but also decentralized AI inference endpoints, Web2 APIs, privacy protocols, and even decentralized social layers like Nostr.
Pocket is no longer just a blockchain relay network—it’s a generalized coordination protocol for open data access. And running a node puts you right at the center of that transformation.
Understanding the Pocket Node: A Non-Boring Breakdown
A Pocket Network node is a participant in the decentralized coordination protocol that facilitates secure, low-latency access to blockchain and open data on the network.
In plain English, a Pocket node is a software instance that connects to supported blockchains and responds to RPC requests sent by dApps connected to the network. It acts as a gateway between these dApps and blockchain data by serving requests, known as relays.
How It Works: Step-by-Step
- Application makes a data request: A dApp wants to know a user’s token balance on Ethereum.
- Request sent to a Pocket Gateway: This request is packaged into a relay and routed by a Gateway.
- Relay session formed: The Pocket protocol assigns a session to serve the app for a fixed time interval.
- Node handles the request: If your node is selected and online, it forwards the query to the connected Ethereum node.
- Node returns the result: The response is sent back through the network to the application.
- Rewards earned: Based on your node’s participation and performance, you earn $Pocket.
Visualizing the Relay Lifecycle
What Sets Pocket Network Nodes Apart (Architectural Uniqueness)
In the Pocket Network ecosystem, a node is more than just a server processing requests—it’s a pivotal component in a decentralized system designed to deliver reliable, permissionless access to open data.
What sets Pocket nodes apart isn’t just decentralization—it’s how deeply permissionless, modular, and extensible their design is.
Here’s what makes a Pocket node structurally unique:
1. Permissionless Operation
Anyone can operate a node or Gateway without approval, creating a truly decentralized supply-side network. This is critical for resilience and aligns with Pocket’s anti-censorship mission.
2. Multi-Service Support
With the Shannon upgrade, nodes are no longer limited to blockchain relays. They can now serve AI inference models (like DeepSeek), public APIs, and even decentralized social data streams. A Pocket node can become the backend for any open system.
3. Token Logic Modules (TLMs)
The introduction of TLMs enables the creation of customizable economic models tailored to specific services. TLMs let different services implement unique reward strategies. For example, a low-latency AI inference node might have higher rewards than a blockchain node during specific demand cycles.
Example of how different TLMs can be applied to different ServiceIDs
4. Modular Cosmos-Based Design
Pocket is built on the Cosmos SDK, providing it with scalability, upgradeability, and potential interoperability with IBC-enabled chains. This supports its goal of becoming a data backbone for all of Web3.
5. Gateway Integration
Nodes work in tandem with Gateways on Pocket, which sit between apps and Suppliers. Gateways can apply pricing, caching, and access control, and route traffic to the best-performing nodes.
How Pocket Nodes Earn and Provide Value (Performance Metrics)
Pocket doesn’t distribute rewards evenly—they’re earned through performance, consistency, and contribution. First is session participation. Every hour, Pocket assigns apps to 5-node relay sessions. Nodes with strong uptime, active stake, and reliable performance are more likely to be included. More sessions mean more relays—and more rewards.
Next is the relay throughput. It’s about volume. Nodes that consistently serve more relays with high quality earn more $POKT. A node handling 20 million relays will earn far more than one serving just 1 million, assuming both maintain low latency and minimal errors.
Finally, QoS enforcement ensures quality. Pocket tracks metrics like response time, accuracy, and archival support. Nodes that fall short aren’t just underpaid—they risk being excluded from future sessions entirely.
Earning Scenario
Here’s an example of what you can earn: if your node handles 5 million relays per day across Ethereum and Gnosis, and each relay earns 0.0000078125 POKT (as per Shannon’s compute unit rate), that adds up to 39.06 POKT daily—or roughly 1,171.9 POKT per month.
At a market rate of $0.05 per token, that’s approximately $58.60 per month. With stronger uptime, lower latency, and multi-chain coverage, high-performing nodes can realistically earn $150 to $250+ per month simply by staying online, responsive, and trusted in sessions.
Why Run a Pocket Node?
There are dozens of reasons someone might want to run a Pocket Network node, but we’ll distill them down to the big three:
- Earn Passive Rewards. When applications send data requests, your node earns POKT tokens if selected in a relay session. With Shannon’s economic model (more on that later), rewards are aligned with usage—the more helpful your node is, the more you earn.
- Support a Decentralized Future: Centralized RPC providers are efficient, but they also carry risks. They introduce single points of failure and vectors for censorship. Pocket nodes are part of the antidote, enabling truly unstoppable apps.
- Get in Early: The Shannon upgrade makes it easier than ever to spin up a node. No more bloated tooling or confusing configurations. Whether you want to test the waters or go full validator, now is a great time to jump in.
Types of Pocket Nodes
Pocket Network operates with two primary node types: Service Nodes and Validator Nodes. Each plays a distinct role in maintaining the network’s decentralized infrastructure and contributes to the protocol’s performance, decentralization, and security.
1. Service Nodes
Service Nodes are the backbone of Pocket Network’s decentralized data layer. They handle incoming relays (data requests) from applications, connect to external blockchains or APIs, and return responses in real time. These nodes are the most accessible entry point for participants looking to contribute to the network.
Key Characteristics:
- Stake Requirement: 60,000 POKT (as per the Shannon upgrade)
- Primary Role: Serve application relays (compute units)
- Earnings: Earn $POKT rewards for each successful relay
- Dependencies: Must connect to supported full/archival nodes (e.g., Ethereum, Gnosis)
- Additional Role: When selected in a session and actively serving data, a Service Node is referred to as a Supplier.
2. Validator Nodes
Validator Nodes are responsible for securing the Pocket blockchain itself. They participate in consensus using Tendermint BFT, propose and sign new blocks, and ensure transaction finality. Validators are fewer in number and require higher uptime, performance, and staking, forming the backbone of Pocket’s chain-level security.
Key Characteristics
- Stake Requirement: Typically ≥150,000 $POKT (top-staked nodes rotate in)
- Role: Validate blocks and secure the network
- Earnings: Earn block rewards and fees for consensus work
- Setup Complexity: Requires high uptime, monitoring, and secure infrastructure.
Node Operators on Pocket Network
Pocket Network is powered by hundreds of node operators globally, many of whom run both Service and Validator nodes to support the ecosystem. Below are some of the most active and reliable participants on POKTscan, with public profiles showing their contributions, performance, and stake activity:
Example of Node Operators On Pocket Network:
- StakeNodes
- CryptoNode Tools
- Liquify Ltd.
- Easy2Stake
- NodeFleet
- Nodies
Which Node Are We Setting Up?
In this guide, we’ll focus on setting up a Service Node—the most widely used entry point into the Pocket ecosystem. Service Nodes directly power decentralized applications by responding to data relays and earn POKT in return.
Setting Up a Pocket Network Service Node On Shannon
This section of the guide walks you through two proven methods for launching your Pocket node: the fast, script-based Cheat Sheet method for quick deployment, and the more customizable Manual Setup for operators who want complete control.
The Cheat Sheet automates dependencies, pulls the latest Pocket Core binaries, bootstraps your node, and gets you relay-ready—all without deep sysadmin knowledge. Meanwhile, the Manual Setup guides you step-by-step through each component, making it ideal for production setups or those who want to understand the infrastructure inside and out.
Let’s get into it. 👇
Checklist: What Do You Need to Get Started?
Here’s what you should have before starting:
Minimum System Requirements
- OS: Linux (Ubuntu/Debian preferred)
- CPU: x86_64 or ARM64
- Access: Root or sudo privileges
- Server: Dedicated VM or physical machine
- Optional: Use the Vultr Playbook for a pre-baked deployment option
Software & Access
- A cloud VPS (any provider) or dedicated server
- SSH access and basic command-line familiarity
- A wallet (funded with over 60,000 POKT if you’re going to stake)
- Optional: jq (for verifying responses via curl).
Important Notes
- Defaults to testnet – The deployment script installs Pocket Testnet by default unless manually reconfigured for Mainnet. If you’re targeting the mainnet (for actual earnings), update the environment variables after setting up the environment.
- Tokens are locked – Once staked, your 60,000 POKT is locked for 21 days if you choose to unstake. There’s no slashing, but downtime or poor performance will cost you in missed rewards.
- Root access is required – The setup script runs with root privileges and installs system-wide services. If you’re on a shared or restricted server, proceed with caution—or manually configure a lower-privilege user.
Quick Start: The Cheat Sheet Method
If you want to get your node online quickly, this is the easiest way to do so. Pocket’s Full Node Cheatsheet uses a bash script to automate the heavy lifting—installing dependencies, syncing with the network, and launching the node with sensible defaults. No deep Linux kung-fu required.
Step 1: Download the Script
Run this from your terminal (on your server):
curl -O https://raw.githubusercontent.com/pokt-network/poktroll/main/tools/scripts/full-node.shThis grabs the latest version of the install script directly from Pocket’s GitHub. No need to clone or browse around—you’re pulling in the production-ready installer.
Step 2: Launch the Installer
Run it with root access:
sudo bash full-node.shThis is where the magic happens. The script walks you through the setup with a few guided questions:
- Choose your network: mainnet, testnet-alpha, or testnet-beta
- Choose a username (it defaults to pocket)
- Enter a moniker—this is just your node’s nickname.
Behind the scenes, the script:
- Installs all required dependencies
- Auto-fetches seeds and genesis files
- Detects your external IP
- Sets up the pocketd binary under Cosmovisor and registers/enables a systemd service so your node will start automatically on reboot.
Step 3: Check That It’s Alive
Want to see if your node is syncing?
curl -s localhost:26657/status | jq '.result.sync_info'If that command returns a block height, you’re officially part of the network. You can also check a whole block like this:
curl -X GET http://localhost:26657/block | jqStep 4: Create/Import Your Wallet
Use this command to create a wallet—the identity your node uses to stake, earn, and interact with the network.
pocketd keys add <key_name>This command generates a new wallet for your node. You’ll receive a public address and a 24-word mnemonic or seed phrase. Please copy that phrase and store it securely. If you lose it, there’s no reset button.
⚠️ Warning: Ensure you store your seed phrase securely. Once you send POKT to this address, losing your seed phrase means you’ll permanently lose access to those funds.
You can also import an existing wallet using one of the following options if you’re migrating from a previous node or using a secure cold wallet.
From a seed phrase:
pocketd keys add <key_name> --recoverFrom a raw private key (hex):
pocketd keys import-hex <key_name> <hex_private_key>Step 5: Fund Your Wallet
Before you can stake and participate, your wallet needs POKT. Fund your wallet with at least 60,000 POKT (i.e. 60000000000 uPOKT) plus a little extra to cover fees. In Shannon, all on-chain amounts use uPOKT (“micro-POKT”):
1 POKT = 1,000,000 uPOKT
So if you plan to stake 60,000 POKT, you must send 60000000000 uPOKT on-chain.
To check your balance on BetaTestnet:
pocketd query bank balances <pokt1…yourAddress> --network betaStep 6: Stake On-Chain as a Supplier
With funds in place, it’s time to register your node and stake:
- Expose Your RPC Port & Get Your IP
EXTERNAL_IP=$(curl -4 ifconfig.me/ip)
sudo ufw allow 8545/tcp
echo "Your public RPC endpoint → http://${EXTERNAL_IP}:8545"- Write Your Stake Config
Save as /tmp/stake_supplier_config.yaml:
owner_address: <pokt1…yourAddress>
operator_address: <pokt1…yourAddress>
stake_amount: "60000000000upokt" # 60,000 POKT in uPOKT
default_rev_share_percent: "<pokt1…yourAddress>": 100 # 100% revenue share back to you
services:
- service_id: "anvil"
endpoints:
- publicly_exposed_url: "http://${EXTERNAL_IP}:8545"
rpc_type: JSON_RPC- Submit Your Stake Transaction
pocketd tx supplier stake-supplier \
--config /tmp/stake_supplier_config.yaml \
--from <your_wallet_name> \
--network betaFinally, verify your Supplier:
pocketd query supplier show-supplier <pokt1…yourAddress> --network betaStep 7: Configure & Launch Your RelayMiner
While your full node maintains the blockchain state and participates in consensus, a RelayMiner is the lightweight proxy that handles JSON-RPC requests from applications (“relays them”) to your node. Think of it as the “gateway” between client apps and your node’s RPC interface.
- Create RelayMiner Config
Save as /tmp/relayminer_config.yaml:
default_signing_key_names: - <your_wallet_name>smt_store_path: $HOME/.pocket/smtpocket_node: query_node_rpc_url: tcp://localhost:26657 query_node_grpc_url: tcp://localhost:9090 tx_node_rpc_url: tcp://localhost:26657suppliers: - service_id: "anvil" service_config: backend_url: "http://127.0.0.1:8546" listen_url: http://0.0.0.0:8545metrics: enabled: false addr: :9090pprof: enabled: false addr: :6060- Start the RelayMiner
pocketd relayminer start \ --grpc-insecure=false \ --log_level=debug \ --config=/tmp/relayminer_config.yaml \ --chain-id=pocket-betaYou’re Live!
- Your full node is syncing,
- Supplier stake is active on-chain,
- RelayMiner is listening for requests,
- You’re now eligible to serve relays and earn POKT rewards.
Curious to Go Deeper? Try the Manual Setup
If the Cheat Sheet is “easy mode,” this is the path for the engineer. The Manual Setup is best suited for those who want complete control, such as customizing configurations, managing ports, or building production-grade nodes. You’ll handle everything yourself: installing dependencies, configuring the node, setting up a reverse proxy, and optionally managing TLS. It takes more time, but for advanced setups or large-scale deployments, it’s the long-term play.
Manual Setup Covers
- Installing Go, pocketd, and dependencies manually
- Creating system users and directories
- Manually fetching chain data (genesis + seeds)
- Running the node with or without Cosmovisor
- (Optional) Configuring a reverse proxy (like NGINX)
- (Optional) Setting up HTTPS with TLS certs
- Staking and wallet management via CLI
Why Choose Manual?
When you need to:
- Run Pocket behind NGINX or a load balancer
- Customize systemd or use Docker
- Troubleshoot performance in detail
- Deploy on cloud networks with strict permissions.
If you’re deploying in a professional setting, the manual route gives you full transparency and fewer surprises.
Final Thoughts: You’re Part of the Backbone Now
Congratulations—you’ve successfully deployed robust, permissionless infrastructure at the heart of Pocket Network. While running a full node, staking your POKT, and launching a RelayMiner may be a technical endeavor, it’s also a vital contribution to the open-data backbone that underpins cutting-edge Web3 applications.
Continue to monitor your node’s performance, apply updates promptly as Shannon evolves, and consider adjusting your stake to optimize rewards. Explore PATH’s capabilities to create tailored gateways, experiment with new data services—be it AI inference or cross-chain indexing—and help drive the next wave of decentralized innovation.
By remaining engaged and inquisitive, you play a crucial role in refining and expanding this permissionless ecosystem. Thank you for joining us at this pivotal moment—together, we’re building the foundation for the future of Web3.