Quickstart Guide

Get started with Yellowstone gRPC streaming in minutes — install a client, authenticate, and subscribe to live Solana slots, blocks, and transactions.

What is Yellowstone gRPC?

Yellowstone gRPC provides direct access to Solana blockchain data through high-performance streaming. Unlike traditional RPC polling, gRPC delivers real-time updates with minimal latency, making it ideal for:

• Trading Bots - Execute trades faster with real-time data
• DeFi Applications - Monitor liquidity pools and token swaps instantly
• Analytics Platforms - Track on-chain activity as it happens
• Arbitrage Systems - Detect opportunities with millisecond precision

Quick Start

1. Subscribe to Yellowstone gRPC

   Subscribe to the standalone gRPC service at €200/month, or get it bundled free with RPC Business and Professional plans. See Pricing & Limits for details.

   Subscribe to Yellowstone gRPC

   What you get:

   • Two Regional Endpoints:
     • EU Region: https://grpc.solanatracker.io
     • US Region: https://grpc-us.solanatracker.io
   • Jito Shreds - 50-100ms faster data delivery
   • No Bandwidth Charges - Unlimited data streaming
   • 24/7 Uptime - Automatic failover and monitoring

   Choose the endpoint closest to your infrastructure for optimal performance. Co-locate in the same data center for sub-millisecond latency.

2. Get Your API Credentials

   After subscribing, retrieve your authentication credentials:

   Get Your API Token

   You’ll receive:

   • x-token - Your authentication token for gRPC requests
   • Endpoint URLs - Both EU and US regions
   • Configuration Guidelines - Recommended settings

   Keep your token secure!

   • Never commit tokens to version control
   • Use environment variables
   • Rotate tokens periodically
3. Install Dependencies

   Install the Yellowstone gRPC client:

   npm install @triton-one/yellowstone-grpc
   

Complete Working Example

Here’s a complete, production-ready example that monitors transactions:

const Client = require("@triton-one/yellowstone-grpc").default;
const { CommitmentLevel } = require("@triton-one/yellowstone-grpc");

// Initialize and connect to Yellowstone gRPC
const getClient = async () => {
  let client = false;
  try {
    client = new Client(
      "https://grpc.solanatracker.io",
      "your-api-key-here",
      {
        "grpc.max_receive_message_length": 100 * 1024 * 1024,
      }
    );
    const version = await client.getVersion();
    if (version) {
      console.log("Connected! Version:", version);
      return client;
    }
  } catch (e) {
    console.error("Failed to connect:", e);
  }
  if (!client) {
    throw new Error("Failed to connect!");
  }
};

(async () => {
  const client = await getClient();
  const stream = await client.subscribe();

  // Handle stream lifecycle
  const streamClosed = new Promise((resolve, reject) => {
    stream.on("error", (error) => {
      console.error("Stream error:", error);
      reject(error);
    });
    stream.on("end", () => {
      console.log("Stream ended");
      resolve();
    });
    stream.on("close", () => {
      console.log("Stream closed");
      resolve();
    });
  });

  // Handle incoming data
  stream.on("data", (data) => {
    if (data?.transaction) {
      const tx = data.transaction.transaction;
      console.log("\n[Transaction]");
      console.log("  Signature:", tx.signature);
      console.log("  Slot:", data.transaction.slot);
      console.log("  Success:", !tx.meta?.err);
      if (tx.meta?.fee) {
        console.log("  Fee:", (tx.meta.fee / 1e9).toFixed(6), "SOL");
      }
    }
  });

  // Subscribe to Token Program transactions
  const request = {
    accounts: {},
    slots: {},
    transactions: {
      tokenTransactions: {
        vote: false,
        failed: false,
        signature: undefined,
        accountInclude: ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"],
        accountExclude: [],
        accountRequired: [],
      },
    },
    transactionsStatus: {},
    entry: {},
    blocks: {},
    blocksMeta: {},
    accountsDataSlice: [],
    ping: undefined,
    commitment: CommitmentLevel.CONFIRMED,
  };

  // Send subscribe request
  await new Promise((resolve, reject) => {
    stream.write(request, (err) => {
      if (err === null || err === undefined) {
        console.log("Subscribed to Token Program transactions");
        resolve();
      } else {
        reject(err);
      }
    });
  }).catch((reason) => {
    console.error("Subscribe failed:", reason);
    throw reason;
  });

  await streamClosed;
})();

What This Example Does

1. Connects to Yellowstone gRPC with proper error handling
2. Creates a stream with lifecycle event handlers
3. Subscribes to transactions involving the Token Program
4. Processes each transaction and logs key details
5. Handles errors gracefully with proper cleanup

Monitoring Different Data Types

Account Updates

Monitor account changes:

const request = {
  accounts: {
    myAccounts: {
      account: ["YourAccountAddress"],
      owner: [],
      filters: []
    }
  },
  slots: {},
  transactions: {},
  transactionsStatus: {},
  entry: {},
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  ping: undefined,
  commitment: CommitmentLevel.CONFIRMED,
};

stream.on("data", (data) => {
  if (data?.account) {
    const account = data.account.account;
    console.log("Account Update:", account.pubkey);
    console.log("Lamports:", account.lamports);
  }
});

Slot Updates

Monitor network slots:

const request = {
  accounts: {},
  slots: {
    slotSubscribe: {}
  },
  transactions: {},
  transactionsStatus: {},
  entry: {},
  blocks: {},
  blocksMeta: {},
  accountsDataSlice: [],
  ping: undefined,
  commitment: CommitmentLevel.CONFIRMED,
};

stream.on("data", (data) => {
  if (data?.slot) {
    console.log("Slot:", data.slot.slot);
    console.log("Parent:", data.slot.parentSlot);
    console.log("Status:", data.slot.status);
  }
});

Block Data

Monitor blocks:

const request = {
  accounts: {},
  slots: {},
  transactions: {},
  transactionsStatus: {},
  entry: {},
  blocks: {},
  blocksMeta: {
    blockMetaSubscribe: {}
  },
  accountsDataSlice: [],
  ping: undefined,
  commitment: CommitmentLevel.CONFIRMED,
};

stream.on("data", (data) => {
  if (data?.blockMeta) {
    console.log("Block:", data.blockMeta.slot);
    console.log("Transactions:", data.blockMeta.transactionCount);
    console.log("Block Hash:", data.blockMeta.blockhash);
  }
});

Environment Variables

Store your credentials securely:

# .env file
GRPC_ENDPOINT=https://grpc.solanatracker.io
GRPC_API_KEY=your-api-key-here

require('dotenv').config();

const client = new Client(
  process.env.GRPC_ENDPOINT,
  process.env.GRPC_API_KEY,
  {
    "grpc.max_receive_message_length": 100 * 1024 * 1024,
  }
);

What’s Next?

Transaction Monitoring

Monitor DEX transactions and program activity

Account Monitoring

Track token holders and account changes

Pump.fun Example

Build a Pump.fun trading bot

Best Practices

Optimize for production

Common Questions

Which endpoint should I use?

Choose based on your location:

• Europe/Global: https://grpc.solanatracker.io
• North America: https://grpc-us.solanatracker.io

Test both endpoints and use the one with lower latency from your deployment region. Aim for ~1ms latency by co-locating in the same data center.

How do I handle reconnections?

Wrap your connection logic in a retry function:

async function connectWithRetry(maxRetries = 5) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await getClient();
    } catch (e) {
      console.log(`Retry ${i + 1}/${maxRetries}...`);
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i)));
    }
  }
  throw new Error("Max retries exceeded");
}

What commitment level should I use?

Commitment levels:

• PROCESSED - Fastest, but can be rolled back
• CONFIRMED - Balanced speed and finality (recommended)
• FINALIZED - Slowest, but guaranteed finalized

For most applications, CONFIRMED is the best choice.

How do I filter transactions?

Use the filter fields in your subscribe request:

transactions: {
  myTransactions: {
    vote: false,                    // Exclude vote transactions
    failed: false,                  // Exclude failed transactions
    accountInclude: ["Address1"],   // Must include any of these (OR)
    accountRequired: ["Address2"],  // Must include all of these (AND)
    accountExclude: ["Address3"],   // Must not include any of these
  }
}

Support & Resources

Support

Get help with your implementation

[e-mail]

Yellowstone gRPC Source

Complete protobuf definitions and protocol specs

View Repository