Sécurité et mise en ligne

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

Publié le Mis à jour le 8 min de lecture

Lire en : English

Sommaire
  1. Pourquoi tout ce qui est dans le front est-il public ?
  2. Que se passe-t-il quand une clé secrète fuite ?
  3. Quelles clés peut-on mettre dans le front, et lesquelles jamais ?
  4. Comment appeler une API payante sans exposer la clé ?
  5. Exemple : une Edge Function Supabase qui appelle OpenAI
  6. Comment vérifier que ton app n'expose aucune clé ?
  7. Que faire si ta clé a déjà fuité ?
  8. Les variables d'environnement suffisent-elles ?
  9. Questions fréquentes
  10. Questions fréquentes
  11. Sources

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 :

OutilPréfixe exposé au navigateurCe 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 :

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 :

ServiceClé publique (front autorisé)Clé secrète (serveur uniquement)Ce qui protège la clé publique
Supabasesb_publishable_... ou anonsb_secret_... ou service_roleLes règles RLS
Stripepk_live_... / pk_test_...sk_live_..., rk_live_...Elle ne peut ni créer de paiement ni lire les données du compte
OpenAI, AnthropicAucuneToutes les clésRien : ne jamais les exposer
Webhooks StripeAucunewhsec_...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.

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 :

Exemple : une Edge Function Supabase qui appelle OpenAI

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

supabase secrets set OPENAI_API_KEY=sk-...

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

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

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 ou Claude Code :

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 :

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. Pour le choix de l'hébergement des fonctions serveur, vois Vercel, Netlify ou hébergement mutualisé, et pour garder un historique propre, Git pour vibe coders. 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