---
title: "Clés API : pourquoi elles ne doivent jamais être dans le front"
description: "Une clé API dans le code du navigateur est lisible par tous. Quelles clés sont publiques, lesquelles sont secrètes, et comment passer par un serveur."
url: "https://vibe-code.blog/blog/cles-api-securite"
lang: "fr"
author: "Thierry Gustin"
published: "2026-11-07"
updated: "2026-11-21"
---

# Clés API : pourquoi elles ne doivent jamais être dans le front

> **L’essentiel** — Tout ce qui est envoyé au navigateur est lisible par n'importe quel visiteur, y compris les variables préfixées VITE_ ou NEXT_PUBLIC_. Une clé secrète (OpenAI, Stripe sk_, Supabase service_role) placée dans le front peut vider ton crédit ou ouvrir ta base. La règle : seules les clés conçues pour être publiques vont côté client ; les autres restent sur un serveur ou une fonction, appelée par ton app.

Une clé API dans le front, c'est une clé de ton appartement scotchée sur la porte. Tout le code envoyé au navigateur peut être lu par n'importe quel visiteur, en deux clics. Si ta clé OpenAI, ta clé secrète Stripe ou ta clé `service_role` de Supabase s'y trouve, quelqu'un finira par la trouver. Voici quelles clés peuvent être publiques, lesquelles jamais, et comment faire passer les appels par un serveur.

## Pourquoi tout ce qui est dans le front est-il public ?

Le front (ou *frontend*), c'est le code qui s'exécute dans le navigateur de ton visiteur. Pour qu'il s'exécute, le navigateur doit le télécharger. Une fois téléchargé, il est lisible : outils de développement (F12), onglet Sources ou Réseau, et une simple recherche du mot `key` suffit.

Minifier ou « cacher » le code n'y change rien. Une clé encodée en base64, découpée en morceaux ou rangée dans une variable au nom anodin reste récupérable : le navigateur doit bien la reconstituer pour l'envoyer.

Le piège propre au vibe coding, ce sont les **préfixes de variables d'environnement** :

| Outil | Préfixe exposé au navigateur | Ce qu'en dit la documentation |
| --- | --- | --- |
| Vite (Lovable, Bolt et beaucoup d'apps React) | `VITE_` | Ces variables sont exposées dans le code client et ne doivent pas contenir de clés API |
| Next.js (v0, beaucoup d'apps Vercel) | `NEXT_PUBLIC_` | La valeur est intégrée au JavaScript envoyé au navigateur au moment du build |

Quand l'IA écrit `VITE_OPENAI_API_KEY` dans ton `.env`, elle n'a pas sécurisé la clé : elle l'a publiée. La documentation de Vite le dit sans détour, et Next.js précise que les variables sans préfixe ne sont disponibles que côté serveur.

## Que se passe-t-il quand une clé secrète fuite ?

Une clé secrète qui fuite donne à quelqu'un d'autre tes droits, sur ta facture. Les conséquences dépendent du service :

- **Clé d'API d'IA (OpenAI, Anthropic, Google)** : quelqu'un fait tourner ses propres requêtes sur ton compte, jusqu'à épuiser ton crédit ou ta limite.
- **Clé secrète Stripe (`sk_live_`)** : Stripe la décrit comme ayant des permissions sans restriction sur toutes ses API. Remboursements, lecture des clients, création de paiements.
- **Clé `service_role` ou `sb_secret_` de Supabase** : elle contourne toutes les règles RLS. Lecture, modification et suppression de toute ta base.
- **Mot de passe SMTP ou clé d'envoi d'e-mails** : ton domaine sert à envoyer du spam, et ta réputation d'expéditeur en pâtit.

Le phénomène n'a rien de marginal. Le rapport *State of Secrets Sprawl 2026* de GitGuardian compte environ 29 millions de secrets détectés sur GitHub public en 2025, dont 1 275 105 clés de services d'IA, en hausse de 81 % sur un an. Le même rapport mesure que les commits assistés par IA ont laissé fuiter des secrets environ deux fois plus souvent que la moyenne.

## Quelles clés peut-on mettre dans le front, et lesquelles jamais ?

Une clé peut aller dans le front seulement si l'éditeur l'a conçue pour ça et que ses droits sont limités par une autre protection. Voici le tri pour les services les plus courants en vibe coding :

| Service | Clé publique (front autorisé) | Clé secrète (serveur uniquement) | Ce qui protège la clé publique |
| --- | --- | --- | --- |
| Supabase | `sb_publishable_...` ou `anon` | `sb_secret_...` ou `service_role` | Les règles RLS |
| Stripe | `pk_live_...` / `pk_test_...` | `sk_live_...`, `rk_live_...` | Elle ne peut ni créer de paiement ni lire les données du compte |
| OpenAI, Anthropic | Aucune | Toutes les clés | Rien : ne jamais les exposer |
| Webhooks Stripe | Aucune | `whsec_...` | Rien : secret de signature |

Pour OpenAI, la consigne officielle est sans ambiguïté : ne déploie jamais ta clé dans un environnement client comme un navigateur ou une app mobile, et fais passer les requêtes par ton propre serveur.

> **Le cas Supabase** — La clé publique de [Supabase](https://supabase.com/) visible dans ton code n'est pas une faille. Ce qui compte, ce sont tes règles RLS. Si elles manquent, la clé publique suffit à lire ta base : tout est expliqué dans [Supabase et RLS : l'erreur qui expose les données](https://vibe-code.blog/blog/supabase-rls).

## Comment appeler une API payante sans exposer la clé ?

La solution est toujours la même : le navigateur appelle **ton** serveur, et c'est ton serveur qui appelle l'API avec la clé. La clé ne quitte jamais le serveur.

Selon ta stack, ce « serveur » prend la forme de :

- une **Edge Function** Supabase, si ton app est faite avec Lovable ou Bolt et Supabase ;
- une **route API** ou une Server Action Next.js, si ton app tourne sur [Vercel](https://vercel.com/) ;
- une **fonction serverless** Netlify ;
- un petit script PHP sur un hébergement mutualisé.

### Exemple : une Edge Function Supabase qui appelle OpenAI

Stocke d'abord la clé comme secret de fonction, jamais dans le code :

```bash
supabase secrets set OPENAI_API_KEY=sk-...
```

Puis la fonction lit la clé côté serveur avec `Deno.env.get` :

```ts
// supabase/functions/assistant/index.ts
Deno.serve(async (req) => {
  // 1. Refuser les appels sans utilisateur connecté
  const auth = req.headers.get("Authorization");
  if (!auth) return new Response("Non autorisé", { status: 401 });

  // 2. Limiter ce que le navigateur peut envoyer
  const { question } = await req.json();
  if (typeof question !== "string" || question.length > 2000) {
    return new Response("Requête invalide", { status: 400 });
  }

  // 3. Appeler l'API avec la clé stockée côté serveur
  const r = await fetch("https://api.openai.com/v1/responses", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${Deno.env.get("OPENAI_API_KEY")}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ model: "NOM_DU_MODELE", input: question }),
  });
  return new Response(await r.text(), { status: r.status });
});
```

Le navigateur n'envoie que la question. Le modèle, la clé et les limites sont fixés côté serveur : un visiteur malveillant ne peut pas choisir un modèle plus cher ni envoyer un roman de 500 pages.

> **Une fonction ouverte reste un robinet** — Déplacer la clé côté serveur ne suffit pas si n'importe qui peut appeler ta fonction en boucle. Vérifie que l'utilisateur est connecté, limite la taille des requêtes, et mets un plafond de dépense chez le fournisseur d'API.

## Comment vérifier que ton app n'expose aucune clé ?

Le contrôle prend dix minutes et se fait en trois endroits : le code, le site en ligne et l'historique Git.

1. **Dans le code** : cherche `sk-`, `sk_live_`, `rk_live_`, `sb_secret_`, `service_role`, `whsec_` et `API_KEY`. Toute occurrence dans un fichier front, ou dans une variable `VITE_` ou `NEXT_PUBLIC_`, est un problème.
2. **Dans le site en ligne** : ouvre F12, onglet Sources, et lance une recherche globale (Ctrl+Maj+F) sur les mêmes motifs. C'est ce que voit un visiteur.
3. **Dans Git** : vérifie que `.env` figure dans `.gitignore`, et que tu ne l'as jamais committé. Un fichier supprimé reste dans l'historique.

Ce prompt fait le tri pour toi dans Lovable, Bolt, [Cursor](https://cursor.com/) ou [Claude Code](https://www.anthropic.com/claude-code) :

```text
Liste toutes les clés, jetons et secrets utilisés dans ce projet.
Pour chacun, indique :
- le service concerné ;
- s'il est conçu pour être public ou secret selon la documentation
  de l'éditeur ;
- où il est utilisé (fichier, et front ou serveur) ;
- s'il est exposé au navigateur (préfixe VITE_, NEXT_PUBLIC_, valeur
  écrite en dur, etc.).
Pour chaque secret exposé, propose de déplacer l'appel dans une
fonction serveur, sans changer le comportement de l'app.
Ne modifie rien avant que je valide.
```

## Que faire si ta clé a déjà fuité ?

Une clé exposée doit être considérée comme compromise, même si tu n'as vu aucun abus. Supprimer le fichier ne suffit pas : la clé peut déjà avoir été copiée.

1. **Révoque ou régénère la clé** chez le fournisseur (OpenAI, Stripe, Supabase). Stripe propose une rotation avec période de grâce de 7 jours au maximum, pour éviter une coupure.
2. **Remplace-la** dans les variables d'environnement de ton serveur ou de ta fonction, puis redéploie. Sur Vercel, une modification des variables ne s'applique qu'aux nouveaux déploiements.
3. **Vérifie l'usage** sur le tableau de bord du fournisseur : requêtes inhabituelles, pics de consommation, paiements ou remboursements suspects.
4. **Installe des garde-fous** : plafond de dépense dur chez ton fournisseur d'IA (OpenAI recommande des limites appliquées, les simples alertes n'arrêtant pas le trafic), et protection contre les pushs de secrets sur GitHub.

Sur ce dernier point, GitHub active par défaut, pour les comptes personnels, une protection qui bloque l'envoi de secrets détectés vers les dépôts publics. Pour les dépôts d'organisation, l'administrateur doit l'activer.

## Les variables d'environnement suffisent-elles ?

Les variables d'environnement protègent une clé seulement si elles restent côté serveur. Une variable `VITE_` ou `NEXT_PUBLIC_` est une variable d'environnement, et elle finit pourtant en clair dans le JavaScript du navigateur.

Les bons réflexes :

- Les clés secrètes vont dans les variables **sans préfixe public**, lues uniquement par le code serveur.
- Sur Vercel, choisis le type **Secret** (valeur non relisible après enregistrement) plutôt que Config pour les clés sensibles.
- Une clé différente par environnement (test, production) et par service : si l'une fuit, tu ne coupes que celle-là.
- L'OWASP recommande aussi la rotation régulière des secrets et le moindre privilège : chez Stripe, préfère une clé restreinte (`rk_`) limitée aux opérations utiles plutôt que la clé secrète complète.

Pour la vue d'ensemble de ce qu'il faut vérifier avant d'ouvrir ton app, reprends la [checklist de sécurité avant mise en ligne](https://vibe-code.blog/blog/securite-vibe-coding). Pour le choix de l'hébergement des fonctions serveur, vois [Vercel, Netlify ou hébergement mutualisé](https://vibe-code.blog/blog/deployer-app-vibe-coding), et pour garder un historique propre, [Git pour vibe coders](https://vibe-code.blog/blog/git-vibe-coding). Si ton app encaisse des paiements, le montage complet est dans Stripe dans une app vibe codée.

## Questions fréquentes

## Questions fréquentes

### Une clé API dans un fichier .env est-elle en sécurité ?

Seulement si ce fichier n'est jamais envoyé au navigateur ni committé sur Git. Le .env lui-même n'est pas public, mais les variables préfixées VITE_ ou NEXT_PUBLIC_ sont intégrées au code JavaScript du site au moment du build. Une clé secrète doit donc être dans une variable sans préfixe, lue uniquement par une fonction serveur, et le fichier .env doit figurer dans .gitignore.

### Puis-je cacher ma clé en l'encodant ou en la découpant ?

Non. Si le navigateur doit envoyer la clé au service, il doit pouvoir la reconstituer, donc n'importe qui peut le faire aussi, en lisant le code ou en observant les requêtes dans l'onglet Réseau. L'encodage base64, l'obfuscation ou le découpage ralentissent à peine un curieux. La seule protection réelle est de garder la clé sur un serveur que le visiteur ne voit pas.

### La clé publishable de Stripe peut-elle être dans mon code ?

Oui. Stripe indique que la clé publishable (pk_live_ ou pk_test_) peut être incluse dans le code front ou les applications distribuées. Elle sert à Stripe.js et aux formulaires de paiement, mais ne peut ni créer de paiement ni lire les données du compte. En revanche, la clé secrète (sk_) et la clé restreinte (rk_) ne doivent jamais quitter ton serveur.

### Comment savoir si ma clé OpenAI a été utilisée par quelqu'un d'autre ?

Ouvre le tableau de bord d'usage de ton compte et cherche des pics de consommation, des modèles que tu n'utilises pas ou des requêtes à des heures inhabituelles. Si tu as le moindre doute, régénère la clé immédiatement et mets à jour ton serveur. Configure ensuite une limite de dépense mensuelle stricte, que OpenAI recommande en plus des simples alertes, qui n'arrêtent pas le trafic.

### Lovable ou Bolt gèrent-ils les clés API correctement ?

Ces outils proposent des moyens de stocker des secrets côté serveur, par exemple via les secrets des Edge Functions de Supabase. Mais si tu colles une clé dans le chat ou demandes un appel direct à une API, le code généré peut la placer côté client. Vérifie après chaque fonctionnalité qui appelle une API payante, avec la recherche globale dans les outils de développement.

## Sources

- [Env Variables and Modes — Vite](https://vite.dev/guide/env-and-mode)
- [How to use environment variables in Next.js — Next.js Docs](https://nextjs.org/docs/app/guides/environment-variables)
- [Best Practices for API Key Safety — OpenAI Help Center](https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety)
- [API keys — Stripe Docs](https://docs.stripe.com/keys)
- [Understanding API keys — Supabase Docs](https://supabase.com/docs/guides/api/api-keys)
- [Environment variables (Edge Functions) — Supabase Docs](https://supabase.com/docs/guides/functions/secrets)
- [Environment variables — Vercel Docs](https://vercel.com/docs/environment-variables)
- [About push protection — GitHub Docs](https://docs.github.com/en/code-security/secret-scanning/introduction/about-push-protection)
- [The State of Secrets Sprawl 2026 — GitGuardian](https://blog.gitguardian.com/the-state-of-secrets-sprawl-2026-pr/)
- [Secrets Management Cheat Sheet — OWASP Cheat Sheet Series](https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html)

— Thierry Gustin, Formateur en intelligence artificielle (GustinAI) · 21 novembre 2026
