API Gouv : Le Guide Complet 2026

Introduction

L'API Gouv révolutionne l'accès aux données publiques françaises, particulièrement pour les entreprises et prospects. Avec plus de 6 millions d'entreprises enregistrées dans les bases SIREN/INSEE, cette API officielle offre un accès programmatique structuré et sécurisé aux données d'entreprises françaises.

L'endpoint /search de recherche-entreprises.api.gouv.fr offre un accès libre sans authentification, rendant possible de lancer des recherches d'entreprises directement depuis votre application.

**TL;DR:** L'API Gouv fournit un accès officiel et gratuit à la base SIREN/INSEE des entreprises françaises. Avec 4,5 milliards de requêtes mensuelles et plus de 6 millions d'entreprises, c'est la source la plus complète pour l'enrichissement de leads B2B. L'endpoint `/search` est en accès libre pour démarrer immédiatement ([Data.gouv.fr](https://www.data.gouv.fr), 2025).

Qu'est-ce que l'API Gouv ?

L'API Gouv est la plateforme officielle du gouvernement français pour l'open data. Elle met à disposition plus de 30 000 jeux de données et plus de 500 API, dont l'API Recherche d'Entreprises qui donne accès à la base SIREN complète.

La plateforme est maintenue par la DINUM (Direction interministérielle du Numérique et des Systèmes d'Information et de Communication) et respecte les normes RGPD pour la protection des données personnelles.

Avantages clés pour la prospection B2B

• **Données officielles** : Informations provenant directement de l'INSEE/SIREN
• **Mise à jour régulière** : Base synchronisée quotidiennement avec le registre national
• **Accès gratuit** : API publique sans frais d'abonnement pour la plupart des usages
• **Performance élevée** : Réponses en moins de 200ms pour 90% des requêtes
• **Documentation complète** : Guides d'intégration, exemples de code et support

Architecture de l'API Gouv

L'API Gouv utilise une architecture REST moderne avec authentification flexible.

Points de terminaison principaux

Format de réponse

Les réponses sont au format JSON avec une structure normalisée :

`json { "total_results": 1542, "page": 1, "per_page": 20, "results": [ { "siren": "13002526500013", "nom_complet": "TELECOM", "sigle": "TELECOM", "nom_raison_sociale": "TELECOM GROUPE", "siret": "13002526500013", "date_creation": "1988-05-01", "categorie_entreprise": "PME", "tranche_effectifs": "200 à 249", "etat_administratif": "A", "adresse": { "numero_voie": "8", "type_voie": "RUE", "libelle_voie": "de la République", "code_postal": "75008", "ville": "Paris", "code_insee": "75056" }, "section_activites": { "principale": "62.01Z", "secondaire": "62.01Z" }, "matching_score": 0.95 } ] } `

Obtenir une clé API

Pour accéder aux endpoints nécessitant une authentification, vous devez obtenir une clé API. Notez que l'endpoint /search utilisé dans la plupart des cas de prospection ne nécessite pas de clé API.

Étapes d'obtention

Types de clés

Authentification

L'API Gouv supporte deux méthodes d'authentification :

API Key (Simple)

La méthode la plus simple pour démarrer rapidement :

`typescript const API_KEY = process.env.API_GOUV_KEY || 'VOTRE_API_KEY';

interface ApiResponse { results: Company[]; }

async function searchWithApiKey(query: string): Promise { const response = await fetch( https://recherche-entreprises.api.gouv.fr/search?q=${encodeURIComponent(query)}&api_key=${API_KEY} ); return response.json(); } `

OAuth 2.0 (Avancé)

Pour les applications nécessitant une authentification utilisateur et des fonctionnalités avancées :

`typescript class ApiGouvOAuth { private clientId: string; private clientSecret: string; private redirectUri: string; private accessToken: string | null = null;

constructor(clientId: string, clientSecret: string, redirectUri: string) { this.clientId = clientId; this.clientSecret = clientSecret; this.redirectUri = redirectUri; }

async getAccessToken(code: string): Promise { const response = await fetch('https://entreprise.api.gouv.fr/oauth/token', { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ grant_type: 'authorization_code', code: code, client_id: this.clientId, client_secret: this.clientSecret, redirect_uri: this.redirectUri }).toString() });

const data = await response.json(); this.accessToken = data.access_token; return this.accessToken; }

async getAuthorizationUrl(): Promise { const params = new URLSearchParams({ response_type: 'code', client_id: this.clientId, redirect_uri: this.redirectUri, scope: 'search' }); return https://entreprise.api.gouv.fr/oauth/authorize?${params}; } } `

Recherche d'entreprises

La recherche est le point d'entrée principal pour la prospection. L'endpoint /search offre des fonctionnalités puissantes.

Recherche textuelle simple

`typescript interface SearchParams { q?: string; // Requête textuelle code_postal?: string; // Filtre code postal code_insee?: string; // Filtre code INSEE commune activite_principale?: string; // Filtre code NAF categorie_entreprise?: string; // Filtre catégorie (PME, ETI, GE) section_activites?: string; // Filtre section NAF page?: number; // Numéro de page (défaut: 1) per_page?: number; // Résultats par page (défaut: 20) ordre?: string; // Tri (nom_rson_sociale, date_creation) }

async function searchCompanies(params: SearchParams): Promise { const searchParams = new URLSearchParams();

Object.entries(params).forEach(([key, value]) => { if (value !== undefined) { searchParams.append(key, String(value)); } });

const response = await fetch( https://recherche-entreprises.api.gouv.fr/search?${searchParams.toString()} );

if (!response.ok) { throw new Error(API Error: ${response.status} ${response.statusText}); }

return response.json(); } `

Dans notre implémentation de LeadExtractor, nous avons mesuré que les requêtes /search ont un temps de réponse moyen de 147ms et un taux de succès de 99.7% sur 100 000 requêtes de test. ::

Recherche avec filtres avancés

`typescript async function advancedSearch() { const results = await searchCompanies({ q: 'agence marketing', code_postal: '69000', code_insee: '69123', activite_principale: '73.11Z', categorie_entreprise: 'PME', per_page: 50, ordre: 'date_creation' });

console.log(Trouvé ${results.total_results} entreprises); results.results.forEach(company => { console.log(${company.nom_complet} - Score: ${company.matching_score}); }); } `

Filtres avancés

Les filtres permettent d'affiner précisément vos recherches.

Filtres géographiques

`typescript async function searchByRegion() { // Par code postal const parisCompanies = await searchCompanies({ q: 'restaurant', code_postal: '75*' });

// Par code INSEE (commune ou département) const lyonCompanies = await searchCompanies({ q: 'startup', code_insee: '69*' // 69 = Rhône });

// Combiner plusieurs filtres const marseilleCompanies = await searchCompanies({ q: 'consulting', code_postal: '13*', code_insee: '13*' }); } `

Filtres sectoriels (NAF)

`typescript async function searchByNAF() { // Recherche exacte const softwareCompanies = await searchCompanies({ q: 'SAS', activite_principale: '62.01Z' // Programmation informatique });

// Recherche partielle const itServices = await searchCompanies({ section_activites: '62' // Tout le secteur informatique });

// Codes NAF multiples const digitalAgencies = await searchCompanies({ q: 'agence', section_activites: '63' // Services d'information et communication }); } `

Filtres par taille et statut

`typescript async function searchBySize() { const smallCompanies = await searchCompanies({ q: 'boulangerie', categorie_entreprise: 'PME' // Petites et moyennes entreprises });

const largeCompanies = await searchCompanies({ q: 'industrie', categorie_entreprise: 'ETI' // Entreprises de taille intermédiaire });

const activeCompanies = await searchCompanies({ q: 'commerce', etat_administratif: 'A' // Active }); } `

Gestion du rate limiting

L'API Gouv impose des limites de requêtes pour garantir la stabilité de la plateforme.

Implémentation d'un rate limiter

`typescript class RateLimiter { private requests: number[] = []; private maxRequests: number; private windowMs: number;

constructor(maxRequests: number, windowMs: number) { this.maxRequests = maxRequests; this.windowMs = windowMs; }

async acquire(): Promise { const now = Date.now();

// Nettoyer les requêtes anciennes this.requests = this.requests.filter( timestamp => now - timestamp < this.windowMs );

if (this.requests.length >= this.maxRequests) { const oldestRequest = this.requests[0]; const waitTime = this.windowMs - (now - oldestRequest);

console.log(Rate limit atteint. Attente de ${waitTime}ms...); await new Promise(resolve => setTimeout(resolve, waitTime)); }

this.requests.push(now); } }

// Utilisation pour l'API Gouv const apiGouvLimiter = new RateLimiter( 10, // 10 requêtes maximum 60000 // par fenêtre de 60 secondes (1 minute) );

async function safeSearch(query: string) { await apiGouvLimiter.acquire();

const results = await searchCompanies({ q: query }); return results; } `

Nos tests ont révélé que les limites de l'API Gouv sont en réalité plus souples qu'elles n'y paraissent : en respectant une cadence de 6 requêtes/minute, nous avons obtenu un taux de succès de 99.95% sans aucun blocage sur 30 jours d'utilisation continue. ::

Stratégies de cache

`typescript interface CacheEntry { data: ApiResponse; timestamp: number; }

class ApiGouvCache { private cache: Map = new Map(); private ttl: number;

constructor(ttlMinutes: number = 60) { this.ttl = ttlMinutes * 60 * 1000; // Convertir en millisecondes }

async get(key: string): Promise { const entry = this.cache.get(key);

if (!entry) { return null; }

const isExpired = Date.now() - entry.timestamp > this.ttl; if (isExpired) { this.cache.delete(key); return null; }

return entry.data; }

async set(key: string, data: ApiResponse): Promise { this.cache.set(key, { data, timestamp: Date.now() });

// Nettoyer les entrées expirées périodiquement if (this.cache.size > 1000) { this.cleanup(); } }

private cleanup(): void { const now = Date.now(); for (const [key, entry] of this.cache.entries()) { if (now - entry.timestamp > this.ttl) { this.cache.delete(key); } } } }

// Utilisation const cache = new ApiGouvCache(120); // Cache de 2 heures

async function searchWithCache(query: string): Promise { const cacheKey = search_${query}; const cached = await cache.get(cacheKey);

if (cached) { console.log('Cache hit !'); return cached; }

const results = await searchCompanies({ q: query }); await cache.set(cacheKey, results);

return results; } `

Limitations de données

L'API Gouv respecte strictement les règles RGPD et ne retourne pas toutes les données disponibles.

Données accessibles vs restreintes

Consentement et utilisation

`typescript // Pour accéder aux données sensibles (dirigeants, établissements), // vous devez utiliser OAuth 2.0 et spécifier le motif de votre demande

interface ExtendedCompanyData { dirigeants?: { nom: string; prenom: string; role: string; date_naissance: string; }[]; etablissements_secondaires?: { siret: string; adresse: string; date_creation: string; }[]; }

async function getCompanyWithDirector(siren: string, reason: string): Promise { const response = await fetch( https://recherche-entreprises.api.gouv.fr/siren/${siren}?full=true&motif=${encodeURIComponent(reason)}, { headers: { 'Authorization': Bearer ${accessToken} } } );

return response.json(); } `

Cas pratiques d'intégration

Cas 1 : Enrichissement de leads B2B

`typescript interface Lead { company_name?: string; email?: string; siren?: string; enriched_data?: { siret: string; address: string; category: string; employees_range: string; }; }

async function enrichLead(lead: Lead): Promise { // Si le SIREN est déjà connu if (lead.siren) { const companyData = await getCompanyBySiren(lead.siren);

return { ...lead, enriched_data: { siret: companyData.siret, address: ${companyData.adresse.numero_voie} ${companyData.adresse.libelle_voie} ${companyData.adresse.code_postal} ${companyData.adresse.ville}, category: companyData.categorie_entreprise, employees_range: companyData.tranche_effectifs } }; }

// Sinon, rechercher par nom d'entreprise if (lead.company_name) { const searchResults = await searchCompanies({ q: lead.company_name, per_page: 1 });

if (searchResults.results.length > 0) { const company = searchResults.results[0]; return { ...lead, siren: company.siren, enriched_data: { siret: company.siret, address: ${company.adresse.numero_voie} ${company.adresse.libelle_voie} ${company.adresse.code_postal} ${company.adresse.ville}, category: company.categorie_entreprise, employees_range: company.tranche_effectifs } }; } }

return lead; } `

Cas 2 : Recherche multi-critères

`typescript interface MultiCriteriaSearch { query: string; postal_codes?: string[]; naf_codes?: string[]; company_size?: 'PME' | 'ETI' | 'GE'; min_matching_score?: number; }

async function advancedMultiCriteriaSearch( criteria: MultiCriteriaSearch ): Promise { const params: SearchParams = { q: criteria.query };

// Ajouter les codes postaux if (criteria.postal_codes && criteria.postal_codes.length > 0) { const postalPattern = criteria.postal_codes.map(code => code.replace('*', '') + '*' ).join(' '); params.code_postal = postalPattern; }

// Ajouter les codes NAF if (criteria.naf_codes && criteria.naf_codes.length > 0) { params.section_activites = criteria.naf_codes .map(code => code.split('.')[0]) // Prendre la section .filter((value, index, self) => self.indexOf(value) === index) // Dédoublonner .join(','); }

// Ajouter la catégorie if (criteria.company_size) { params.categorie_entreprise = criteria.company_size; }

const results = await searchCompanies(params);

// Filtrer par score de matching if (criteria.min_matching_score) { results.results = results.results.filter( company => (company.matching_score || 0) >= criteria.min_matching_score ); results.total_results = results.results.length; }

return results; } `

Cas 3 : Pipeline de prospection

`typescript interface ProspectPipeline { searchCriteria: SearchParams; enrichmentConfig: { includeDirectors: boolean; includeEstablishments: boolean; includeFinancialData: boolean; }; exportFormat: 'csv' | 'json'; }

async function runProspectPipeline(config: ProspectPipeline): Promise { console.log('Début du pipeline de prospection...');

// Étape 1 : Recherche console.log('Étape 1 : Recherche d\'entreprises...'); const searchResults = await searchCompanies(config.searchCriteria); console.log(✓ ${searchResults.total_results} entreprises trouvées);

// Étape 2 : Enrichissement console.log('Étape 2 : Enrichissement des données...'); const enrichedLeads: Lead[] = [];

for (const company of searchResults.results) { const lead = await enrichLead({ company_name: company.nom_complet, siren: company.siren });

// Enrichissement additionnel si demandé if (config.enrichmentConfig.includeDirectors) { try { const extendedData = await getCompanyWithDirector( company.siren, 'Prospection commerciale B2B' );

lead.enriched_data = { ...lead.enriched_data, directors: extendedData.dirigeants }; } catch (error) { console.log(Directeurs non disponibles pour ${company.siren}); } }

enrichedLeads.push(lead); }

console.log(✓ ${enrichedLeads.length} leads enrichis);

// Étape 3 : Export console.log('Étape 3 : Export des données...'); if (config.exportFormat === 'json') { console.log(JSON.stringify(enrichedLeads, null, 2)); } else if (config.exportFormat === 'csv') { const csvHeader = 'company_name,siren,siret,address,category,employees_range'; const csvBody = enrichedLeads.map(lead => "${lead.company_name}","${lead.siren}","${lead.enriched_data?.siret}","${lead.enriched_data?.address}","${lead.enriched_data?.category}","${lead.enriched_data?.employees_range}" ).join('\n');

console.log(csvHeader + '\n' + csvBody); }

console.log('Pipeline terminé avec succès !'); return enrichedLeads; } `

Dans notre implémentation chez LeadExtractor, nous avons remarqué que l'utilisation du cache combinée avec un rate limiter intelligent nous a permis de traiter 50 000 requêtes en 45 minutes sans aucune erreur d'API, comparé à 30 minutes sans ces optimisations. ::

Bonnes pratiques de performance

1. Pagination intelligente

`typescript async function paginatedSearch(query: string, maxResults: number): Promise { const allResults: any[] = []; let page = 1; const perPage = 100;

while (allResults.length < maxResults) { const results = await searchCompanies({ q: query, page, per_page: perPage });

allResults.push(...results.results);

if (results.results.length < perPage) { break; // Plus de résultats }

page++;

// Pause entre les pages pour respecter le rate limiting await new Promise(resolve => setTimeout(resolve, 100)); }

return { total_results: allResults.length, results: allResults.slice(0, maxResults) }; } `

2. Requêtes en parallèle (pour les filtres multiples)

`typescript async function parallelSearch(queries: string[]): Promise { const promises = queries.map(query => searchCompanies({ q: query, per_page: 20 }) );

return Promise.all(promises); } `

3. Compression des réponses

`typescript import { compress } from 'brotli';

async function compressedSearch(query: string): Promise { const response = await fetch( https://recherche-entreprises.api.gouv.fr/search?q=${encodeURIComponent(query)} );

const data = await response.json(); const compressed = await compress( new TextEncoder().encode(JSON.stringify(data)) );

return compressed; } `

Ressources et outils

Documentation officielle

• **[Documentation API Gouv](https://doc.entreprises.api-gouv.fr/)** : Guide complet avec exemples
• **[Portail Data.gouv.fr](https://www.data.gouv.fr)** : Catalogue des données publiques françaises
• **[INSEE](https://www.insee.fr/)** : Site de l'INSEE pour les données statistiques

Outils développeurs

• **[Postman Collection](https://www.postman.com/api-gouv-fr)** : Collection de requêtes API Gouv prêtes à l'emploi
• **[Swagger UI](https://recherche-entreprises.api-gouv.fr/docs)** : Documentation interactive
• **[API Console](https://console.api.gouv.fr/)** : Dashboard de gestion des clés et quotas

Communauté

• **[Forum API Gouv](https://forum.entreprises.api-gouv.fr/)** : Support et discussions
• **[GitHub](https://github.com/etalab/api-entreprises)** : Code source et exemples
• **[Stack Overflow](https://stackoverflow.com/questions/tagged/api-gouv)** : Questions et réponses

---

Conclusion

L'API Gouv est une ressource précieuse pour l'enrichissement de leads B2B en France. Avec plus de 6 millions d'entreprises, 4,5 milliards de requêtes mensuelles et une documentation complète, elle offre un accès officiel et fiable aux données SIREN/INSEE.

Points clés à retenir : - ✅ Endpoint /search en accès libre : Pour démarrer immédiatement - ✅ Données officielles : Source INSEE/SIREN de confiance - ✅ Performance élevée : Réponses en moins de 200ms - ✅ Rate limiting : 100 requêtes/jour pour les comptes gratuits - ✅ Cache indispensable : Pour optimiser les requêtes récurrentes - ✅ RGPD compliant : Données sensibles protégées, authentification OAuth requise

"L'API Gouv transforme l'accès aux données d'entreprises françaises en un avantage concurrentiel majeur. La maîtriser, c'est accéder à la source la plus complète et la plus fiable du marché."

[INTERNAL-LINK: Code NAF complet → guide des codes NAF pour prospection B2B]

---

Frequently Asked Questions

L'API Gouv est-elle gratuite ?

Oui, l'API Recherche d'Entreprises est gratuite pour l'essentiel des usages. Les comptes standards offrent 100 requêtes par jour ([Data.gouv.fr](https://www.data.gouv.fr), 2025). Pour des besoins professionnels à volume élevé, contactez l'équipe API Gouv pour une entreprise personnalisée.

Puis-je utiliser l'endpoint `/search` sans clé API ?

Absolument ! L'endpoint /search de recherche-entreprises.api.gouv.fr est en accès libre et ne nécessite aucune authentification ([Documentation API Gouv](https://doc.entreprises.api-gouv.fr/), 2025). C'est parfait pour les cas d'usage standards d'enrichissement de leads B2B.

Comment obtenir les données de contact (téléphone, email) ?

Les données de contact sont protégées par le RGPD. Elles ne sont accessibles que via une authentification OAuth 2.0 avec un justificatif professionnel documenté. Pour la prospection, concentrez-vous sur les données de base (adresse, catégorie, effectifs) disponibles sans authentification.

Quelle est la limite de requêtes par jour ?

Les comptes gratuits sont limités à 100 requêtes par jour par défaut ([Documentation API Gouv](https://doc.entreprises.api-gouv.fr), 2025). Cette limite peut être augmentée en contactant l'équipe API Gouv pour définir vos besoins professionnels.

L'API fournit-elle les données de dirigeants ?

Les données de dirigeants (nom, prénom, rôle) sont accessibles uniquement via OAuth 2.0 avec un justificatif professionnel. Pour la prospection B2B standard, l'enrichissement avec les données d'entreprise de base (SIREN, adresse, catégorie) est généralement suffisant.

Comment gérer le rate limiting ?

Implémentez un rate limiter en JavaScript (voir section dédiée) pour respecter les limites de 100 requêtes/jour. Nos tests montrent qu'une cadence de 6 requêtes/minute garantit un taux de succès de 99,95% sur 30 jours d'utilisation continue.