> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Gatekeeper (Beta)

> Helius's high-performance edge gateway purpose-built for Solana

Gatekeeper is Helius's new edge gateway, now in public beta, that removes Cloudflare from the critical path. Eliminating our edge latency unlocks the true speed of our core APIs and services—response time improvements range from tens to hundreds of milliseconds.

Gatekeeper acts as a single, unified entry-point for all requests (e.g., JSON-RPC, WebSockets, and Helius APIs): it terminates connections at geographically distributed edge locations, and intelligently routes requests to our backend infrastructure.

For latency-critical workloads, Gatekeeper provides the shortest network path, reducing hops and shaving off milliseconds.

## Quickstart

To use Gatekeeper, replace your existing endpoint with the Gatekeeper (Beta) endpoint:

<CodeGroup>
  ```javascript Before theme={"system"}
  const url = "https://mainnet.helius-rpc.com?api-key=YOUR_API_KEY";
  ```

  ```javascript After theme={"system"}
  const url = "https://beta.helius-rpc.com?api-key=YOUR_API_KEY";
  ```
</CodeGroup>

**That's it!**

Your existing API key works without any additional changes.

## Supported Methods

Gatekeeper currently supports:

* All standard Solana RPC endpoints
* All Helius-specific RPC endpoints (e.g., gTFA) 
* All Helius WebSocket endpoints (standard Solana methods plus the Helius extensions like `transactionSubscribe`)
* All DAS API endpoints
* All Photon API endpoints (i.e., ZK Compression)
* The Helius Priority Fee API
* The Enhanced Transactions API

<Note>
  **Currently not supported**: LaserStream is not yet available on Gatekeeper. Continue using the dedicated [LaserStream endpoints](/laserstream/grpc#mainnet-endpoints) for gRPC connections.
</Note>

## Usage Examples

<CodeGroup>
  ```javascript JavaScript/TypeScript theme={"system"}
  const url = `https://beta.helius-rpc.com?api-key=${YOUR_API_KEY}`;

  const response = await fetch(url, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getLatestBlockhash',
      params: []
    })
  });

  const data = await response.json();
  console.log(data);
  ```

  ```python Python theme={"system"}
  import requests

  url = f"https://beta.helius-rpc.com?api-key={YOUR_API_KEY}"

  response = requests.post(url, json={
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getLatestBlockhash",
      "params": []
  })

  print(response.json())
  ```

  ```rust Rust theme={"system"}
  use reqwest;
  use serde_json::json;

  #[tokio::main]
  async fn main() -> Result<(), Box<dyn std::error::Error>> {
      let url = format!("https://beta.helius-rpc.com?api-key={}", YOUR_API_KEY);

      let client = reqwest::Client::new();
      let response = client
          .post(&url)
          .json(&json!({
              "jsonrpc": "2.0",
              "id": 1,
              "method": "getLatestBlockhash",
              "params": []
          }))
          .send()
          .await?;

      let data = response.json::<serde_json::Value>().await?;
      println!("{:?}", data);

      Ok(())
  }
  ```

  ```bash cURL theme={"system"}
  curl https://beta.helius-rpc.com?api-key=YOUR_API_KEY \
    -X POST \
    -H "Content-Type: application/json" \
    -d '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "getLatestBlockhash",
      "params": []
    }'
  ```
</CodeGroup>

## WebSocket Support

Gatekeeper supports Helius WebSockets — both the standard Solana subscription methods and the Helius extensions (`transactionSubscribe`, enhanced `accountSubscribe`) — with the same performance improvements.

```javascript theme={"system"}
const ws = new WebSocket(`wss://beta.helius-rpc.com?api-key=${YOUR_API_KEY}`);

ws.on('open', () => {
  ws.send(JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'transactionSubscribe',
    params: [
      {
        accountInclude: ['YOUR_ACCOUNT_ADDRESS']
      },
      {
        commitment: 'confirmed',
        encoding: 'jsonParsed',
        transactionDetails: 'full',
        showRewards: true,
        maxSupportedTransactionVersion: 0
      }
    ]
  }));
});

ws.on('message', (data) => {
  console.log('Transaction:', JSON.parse(data));
});
```

## What to Expect

During the beta period:

* **Lower Latency** - Significantly faster response times across the board
* **Better Performance Under Load** - Improved reliability during high-traffic periods
* **More Consistent Response Times** - Reduced variance in latency
* **Improved WebSocket Stability** - More reliable real-time connections
* **Full API Compatibility** - All existing RPC methods work identically
* **Same Pricing** - No additional cost for beta access
* **Global Distribution** - Edge nodes across multiple continents

## Who should use Gatekeeper?

Gatekeeper is ideal for applications where performance matters:

* **High-Frequency Applications** - Any app where latency matters
* **Trading Bots** - Maximum speed for arbitrage opportunities
* **DeFi Protocols** - Real-time price feeds and fast transaction submission
* **Gaming Applications** - Low response times for smooth UX
* **NFT Marketplaces** - Instant minting and low-latency queries

## Migration Checklist

<Steps>
  <Step title="Update Your Endpoint">
    Change `mainnet.helius-rpc.com` to `beta.helius-rpc.com` in your code
  </Step>

  <Step title="Test in Development">
    Run your test suite to verify everything works as expected
  </Step>

  <Step title="Monitor Performance">
    Check your metrics—you should see improved latency and more consistent response times
  </Step>

  <Step title="Deploy to Production">
    Once verified, deploy your changes to production
  </Step>
</Steps>

## Rollback

If you need to rollback for any reason, simply switch back to the standard endpoint:

```javascript theme={"system"}
const url = "https://mainnet.helius-rpc.com?api-key=YOUR_API_KEY";
```

## Limitations & Known Issues

<Warning>
  **Beta Status**: Gatekeeper is production-ready but still being optimized. We recommend testing in development before switching production traffic.
</Warning>

**Not yet supported:**

* **LaserStream**: Use the dedicated [LaserStream endpoints](/laserstream/grpc#mainnet-endpoints) for gRPC connections

**Current status:**

* Some advanced features are still being rolled out
* We're continuously optimizing routing algorithms
* Performance improvements are ongoing

## Rollout Plan

Gatekeeper is currently **opt-in** while we optimize performance and gather feedback.

Timeline:

* **Now**: Public beta available to all users
* **Coming Weeks**: Additional optimizations and performance improvements
* **Coming Months**: Gradual migration of all traffic to Gatekeeper as the default

## Feedback & Support

We're actively monitoring Gatekeeper's performance and would love your feedback:

* **Issues or questions?** Contact [support@helius.dev](mailto:support@helius.dev)
* **Join our Discord** for real-time discussion: [https://discord.com/invite/6GXdee3gBj](https://discord.com/invite/6GXdee3gBj)
* **Report bugs** through your developer dashboard

## FAQs

<AccordionGroup>
  <Accordion title="Do I need a new API key?">
    No. Your existing API key works with Gatekeeper without any changes.
  </Accordion>

  <Accordion title="Will Gatekeeper cost extra?">
    No. Gatekeeper is available at no additional cost. Your existing pricing plan applies.
  </Accordion>

  <Accordion title="What endpoints are supported on Gatekeeper?">
    All JSON-RPC endpoints are fully supported, including standard Solana RPC methods, Helius-specific RPC endpoints (e.g., gTFA), DAS, Photon, Priority Fee API, and the Enhanced Transactions API. WebSockets — both the standard Solana subscription methods and the Helius extensions like `transactionSubscribe` — are also supported.
  </Accordion>

  <Accordion title="What endpoints are not yet supported on Gatekeeper?">
    LaserStream is not yet available on Gatekeeper. For gRPC connections, use the dedicated [LaserStream endpoints](/laserstream/grpc#mainnet-endpoints).
  </Accordion>

  <Accordion title="What if I encounter issues using Gatekeeper?">
    You can easily rollback by switching back to `mainnet.helius-rpc.com`. Contact [support](https://www.helius.dev/docs/support) if you need help.
  </Accordion>

  <Accordion title="When will Gatekeeper become the default?">
    We're planning a gradual rollout over the coming months. We'll notify all users before making any changes to the default Helius endpoints.
  </Accordion>

  <Accordion title="Can I use Gatekeeper on Solana Devnet or Testnet?">
    No, Gatekeeper is currently only available on Solana Mainnet. Solana Devnet and Testnet support is coming soon.
  </Accordion>
</AccordionGroup>

## Get Started

<CardGroup cols={2}>
  <Card title="Try Gatekeeper" icon="rocket" href="https://www.helius.dev/docs/gatekeeper/migration-guide">
    Migrate to Gatekeeper in less than 5 minutes
  </Card>

  <Card title="Learn About Gatekeeper" icon="book" href="https://www.helius.dev/blog/introducing-gatekeeper">
    Read our blog to understand how Gatekeeper works
  </Card>
</CardGroup>