> ## 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)

> Passerelle de périphérie haute performance d'Helius conçue pour Solana

Gatekeeper est la nouvelle passerelle de périphérie d'Helius, actuellement en bêta publique, qui supprime Cloudflare du chemin critique. L'élimination de notre latence de bord débloque la véritable vitesse de nos API et services principaux — les améliorations des temps de réponse varient de dizaines à des centaines de millisecondes.

Gatekeeper agit comme un point d'entrée unique et unifié pour toutes les requêtes (par exemple, JSON-RPC, WebSockets et les API Helius) : il termine les connexions à des emplacements de périphérie géographiquement distribués et achemine intelligemment les requêtes vers notre infrastructure backend.

Pour les charges de travail sensibles à la latence, Gatekeeper offre le chemin réseau le plus court, réduisant les sauts et économisant des millisecondes.

## Démarrage rapide

Pour utiliser Gatekeeper, remplacez votre endpoint existant par l'endpoint Gatekeeper (Beta) :

<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>

**C'est tout !**

Votre clé API existante fonctionne sans aucun changement supplémentaire.

## Méthodes prises en charge

Gatekeeper prend actuellement en charge :

* Tous les endpoints RPC standard de Solana
* Tous les endpoints RPC spécifiques à Helius (par exemple, gTFA)
* Tous les endpoints WebSocket d'Helius (méthodes standards de Solana plus les extensions Helius comme `transactionSubscribe`)
* Tous les endpoints API DAS
* Tous les endpoints API Photon (c'est-à-dire ZK Compression)
* L'API des frais prioritaires Helius
* L'API des transactions améliorées

<Note>
  **Actuellement non pris en charge** : LaserStream n'est pas encore disponible sur Gatekeeper. Continuez à utiliser les [endpoints LaserStream](/docs/fr/laserstream/grpc#endpoints-mainnet) dédiés pour les connexions gRPC.
</Note>

## Exemples d'utilisation

<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>

## Support WebSocket

Gatekeeper prend en charge les WebSockets Helius — à la fois les méthodes d'abonnement standards de Solana et les extensions Helius (`transactionSubscribe`, enhanced `accountSubscribe`) — avec les mêmes améliorations de performance.

```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: 1
      }
    ]
  }));
});

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

## À quoi s'attendre

Pendant la période bêta :

* **Latence réduite** - Temps de réponse nettement plus rapides
* **Meilleure performance sous charge** - Fiabilité améliorée pendant les périodes de trafic élevé
* **Temps de réponse plus constants** - Réduction de la variance de latence
* **Stabilité WebSocket améliorée** - Connexions en temps réel plus fiables
* **Compatibilité complète des API** - Toutes les méthodes RPC existantes fonctionnent de manière identique
* **Même tarification** - Pas de coût supplémentaire pour l'accès bêta
* **Distribution mondiale** - Nœuds de périphérie sur plusieurs continents

## Qui devrait utiliser Gatekeeper ?

Gatekeeper est idéal pour les applications où la performance est cruciale :

* **Applications à haute fréquence** - Toute application où la latence est importante
* **Bots de trading** - Vitesse maximale pour les opportunités d'arbitrage
* **Protocols DeFi** - Flux de prix en temps réel et soumission rapide des transactions
* **Applications de jeu** - Faible temps de réponse pour une UX fluide
* **Marketplaces NFT** - Frappe instantanée et requêtes à faible latence

## Liste de vérification pour la migration

<Steps>
  <Step title="Mettez à jour votre endpoint">
    Changez `mainnet.helius-rpc.com` en `beta.helius-rpc.com` dans votre code
  </Step>

  <Step title="Testez en développement">
    Exécutez votre suite de tests pour vérifier que tout fonctionne comme prévu
  </Step>

  <Step title="Surveillez la performance">
    Vérifiez vos métriques — vous devriez voir une latence améliorée et des temps de réponse plus constants
  </Step>

  <Step title="Déployez en production">
    Une fois vérifié, déployez vos modifications en production
  </Step>
</Steps>

## Revenir en arrière

Si vous devez revenir en arrière pour une raison quelconque, il suffit de revenir à l'endpoint standard :

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

## Limitations et problèmes connus

<Warning>
  **Statut bêta** : Gatekeeper est prêt pour la production mais est toujours en cours d'optimisation. Nous recommandons de tester en développement avant de changer le trafic de production.
</Warning>

**Pas encore pris en charge :**

* **LaserStream** : Utilisez les [endpoints LaserStream](/docs/fr/laserstream/grpc#endpoints-mainnet) dédiés pour les connexions gRPC

**Statut actuel :**

* Certaines fonctionnalités avancées sont encore en cours de déploiement
* Nous optimisons continuellement les algorithmes de routage
* Les améliorations de performance sont en cours

## Plan de déploiement

Gatekeeper est actuellement **opt-in** pendant que nous optimisons la performance et recueillons des retours.

Chronologie :

* **Maintenant** : Bêta publique disponible pour tous les utilisateurs
* **Prochaines semaines** : Optimisations supplémentaires et améliorations de performance
* **Prochains mois** : Migration progressive de tout le trafic vers Gatekeeper comme par défaut

## Retours & Support

Nous surveillons activement les performances de Gatekeeper et serions ravis de recevoir vos commentaires :

* **Problèmes ou questions ?** Contactez [support@helius.dev](mailto:support@helius.dev)
* **Rejoignez notre Discord** pour des discussions en temps réel : [https://discord.com/invite/6GXdee3gBj](https://discord.com/invite/6GXdee3gBj)
* **Signalez les bugs** via votre tableau de bord développeur

## FAQ

<AccordionGroup>
  <Accordion title="Ai-je besoin d'une nouvelle clé API ?">
    Non. Votre clé API existante fonctionne avec Gatekeeper sans aucun changement.
  </Accordion>

  <Accordion title="Gatekeeper coûtera-t-il plus cher ?">
    Non. Gatekeeper est disponible sans coût supplémentaire. Votre plan de tarification existant s'applique.
  </Accordion>

  <Accordion title="Quels endpoints sont pris en charge sur Gatekeeper ?">
    Tous les endpoints JSON-RPC sont entièrement pris en charge, y compris les méthodes RPC standards de Solana, les endpoints RPC spécifiques à Helius (par exemple, gTFA), DAS, Photon, l'API des frais prioritaires et l'API des transactions améliorées. WebSockets — à la fois les méthodes d'abonnement standards de Solana et les extensions Helius comme `transactionSubscribe` — sont également pris en charge.
  </Accordion>

  <Accordion title="Quels endpoints ne sont pas encore pris en charge sur Gatekeeper ?">
    LaserStream n'est pas encore disponible sur Gatekeeper. Pour les connexions gRPC, utilisez les [endpoints LaserStream](/docs/fr/laserstream/grpc#endpoints-mainnet) dédiés.
  </Accordion>

  <Accordion title="Que faire si je rencontre des problèmes en utilisant Gatekeeper ?">
    Vous pouvez facilement revenir en arrière en changeant pour `mainnet.helius-rpc.com`. Contactez [support](https://www.helius.dev/docs/support) si vous avez besoin d'aide.
  </Accordion>

  <Accordion title="Quand Gatekeeper deviendra-t-il par défaut ?">
    Nous prévoyons un déploiement progressif au cours des prochains mois. Nous informerons tous les utilisateurs avant de modifier les endpoints par défaut de Helius.
  </Accordion>

  <Accordion title="Puis-je utiliser Gatekeeper sur Solana Devnet ou Testnet ?">
    Non, Gatekeeper est actuellement uniquement disponible sur Solana Mainnet. Le support pour Solana Devnet et Testnet arrive bientôt.
  </Accordion>
</AccordionGroup>

## Mettez-vous en route

<CardGroup cols={2}>
  <Card title="Essayer Gatekeeper" icon="rocket" href="https://www.helius.dev/docs/gatekeeper/migration-guide">
    Migrer vers Gatekeeper en moins de 5 minutes
  </Card>

  <Card title="En savoir plus sur Gatekeeper" icon="book" href="https://www.helius.dev/blog/introducing-gatekeeper">
    Lisez notre blog pour comprendre comment fonctionne Gatekeeper
  </Card>
</CardGroup>