Quarrywise

API Sirene sans clé INSEE : exporter des entreprises en CSV

Deux API publiques donnent accès aux données Sirene. L'une demande une clé INSEE, l'autre non. Requêtes testées, limite des 10 000 résultats et script Python pour exporter un CSV.

Requêtes et scripts testés le 26 octobre 2026.

Vous cherchez la liste des entreprises d'un secteur (un code NAF) dans un département, avec leur SIREN et leur SIRET, dans un fichier CSV que vous pouvez ouvrir dans Excel ou charger dans un CRM. Deux API publiques donnent accès aux données Sirene : l'API Sirene de l'INSEE, qui demande un compte et une clé, et l'API Recherche d'entreprises, ouverte sans clé. Ce tutoriel compare les deux, montre des requêtes curl que nous avons testées le 26 octobre 2026, explique la limite des 10 000 résultats et la façon de la contourner proprement, avec un script Python complet.

Deux API pour les données Sirene

L'API INSEE Sirene : compte et clé obligatoires

L'API Sirene officielle se trouve sur le portail des API de l'INSEE. D'après le guide de connexion de l'INSEE, il faut :

  1. créer un compte sur le portail ;
  2. créer une « application » depuis le tableau de bord ;
  3. souscrire à l'API Sirene avec le plan « Public », le seul proposé ;
  4. récupérer la clé générée, à transmettre dans l'en-tête HTTP X-INSEE-Api-Key-Integration de chaque requête.

Le quota est de 30 requêtes par minute, et la pagination par curseur permet de récupérer jusqu'à 1 000 résultats par page (lettre Sirene open data de juin 2026). La fiche data.gouv.fr de l'API la classe en accès « ouvert avec compte », sous Licence Ouverte 2.0.

Sans clé, l'API répond simplement 401 :

curl -s -A "MonExport/1.0 (contact@example.com)" "https://api.insee.fr/api-sirene/3.11/siren/552032534"
# {"message":"Unauthorized","http_status_code":401}

C'est le bon choix si vous avez besoin de l'ensemble des données Sirene diffusibles, unités légales et établissements, au-delà d'une simple recherche. Pour un usage massif, l'INSEE publie aussi chaque mois les fichiers stock de la base Sirene sur data.gouv.fr.

L'API Recherche d'entreprises : sans clé ni compte

L'API Recherche d'entreprises, publiée par la DINUM, est celle qui alimente l'Annuaire des Entreprises. Elle sert les données Sirene de l'INSEE et celles du RNE, sans clé et sans compte. Sa documentation OpenAPI précise :

  • au maximum 7 requêtes par seconde par adresse IP et 30 par seconde par ASN (vous pouvez donc atteindre la limite sur un cloud public) ;
  • une réponse 429 Too Many Requests avec un en-tête Retry-After en cas de dépassement ;
  • un en-tête User-Agent explicite est recommandé ;
  • les entreprises non diffusibles ne sont pas accessibles.

La documentation prévient aussi que cette API sert à rechercher des entreprises, pas à accéder aux données complètes de la base Sirene. Les données sont publiées sous Licence Ouverte 2.0, qui autorise la réutilisation, y compris commerciale, à condition de citer la source et la date de dernière mise à jour.

API Sirene (INSEE) API Recherche d'entreprises
Accès compte, application, clé aucun
Débit 30 requêtes par minute 7 requêtes par seconde par IP
Résultats par page jusqu'à 1 000 (curseur) 25 au maximum
Pagination par curseur page × per_page ≤ 10 000
Usage prévu données Sirene diffusibles, unités légales et établissements recherche d'entreprises, sans les non diffusibles

Premières requêtes curl

Sous Windows PowerShell, curl est un alias d'une autre commande : tapez curl.exe à la place, et écrivez la commande sur une seule ligne (les \ de fin de ligne ne fonctionnent que dans un shell de type bash). Remplacez le User-Agent par le nom de votre outil et un contact.

API Siren et API Siret : retrouver une entreprise par son numéro

Le paramètre q accepte un nom, un SIREN ou un SIRET :

curl -s -A "MonExport/1.0 (contact@example.com)" \
  "https://recherche-entreprises.api.gouv.fr/search?q=552032534&minimal=true&include=siege"

minimal=true&include=siege allège la réponse : seuls l'unité légale et son siège sont renvoyés. Extrait de la réponse obtenue :

{
  "siren": "552032534",
  "nom_raison_sociale": "DANONE",
  "activite_principale": "70.10Z",
  "nature_juridique": "5599",
  "categorie_entreprise": "GE",
  "date_creation": "1955-01-01",
  "etat_administratif": "A",
  "siege": {
    "siret": "55203253400703",
    "code_postal": "75009",
    "libelle_commune": "PARIS",
    "departement": "75"
  }
}

La même requête avec q=55203253400703 (le SIRET du siège) renvoie la même entreprise.

Lister les entreprises d'un code NAF dans un département

curl -s -A "MonExport/1.0 (contact@example.com)" \
  "https://recherche-entreprises.api.gouv.fr/search?activite_principale=62.01Z&departement=35&est_entrepreneur_individuel=false&per_page=25&page=1"

La réponse contient results et quatre compteurs. Le 26 octobre 2026, nous avons obtenu "total_results": 1253, "page": 1, "per_page": 25, "total_pages": 51.

Les filtres utiles pour un export :

  • activite_principale : code NAF de l'unité légale, par exemple 62.01Z ;
  • departement : attention, il retient les entreprises qui ont au moins un établissement dans le département, pas seulement celles dont le siège s'y trouve ;
  • tranche_effectif_salarie : tranche d'effectif INSEE (NN, 00, 01 ... 53) ;
  • nature_juridique : catégorie juridique sur quatre chiffres, par exemple 5710 pour une SAS ;
  • etat_administratif : A (active) ou C (cessée), une seule valeur à la fois ;
  • est_entrepreneur_individuel=false : exclut les entrepreneurs individuels, dont le nom est celui d'une personne physique.

Les filtres de liste acceptent plusieurs valeurs séparées par des virgules. Il n'existe pas de filtre sur la date de création : il faut filtrer cette date après coup.

Les limites de pagination : per_page et le plafond des 10 000

Deux règles encadrent la pagination, et l'API les annonce clairement dans ses messages d'erreur.

per_page va de 1 à 25 (10 par défaut). Avec per_page=26, l'API répond 400 : « Veuillez indiquer un paramètre per_page entre 1 et 25, par défaut 10. »

page × per_page ne peut pas dépasser 10 000. Avec per_page=25, la page 400 fonctionne et la page 401 renvoie une erreur 400 : « Le nombre total de résultats est restreint à 10 000 ».

Deux conséquences pratiques :

  1. total_results est lui-même plafonné. Pour activite_principale=62.01Z sur toute la France, l'API annonce exactement 10 000 : lisez « 10 000 ou plus ».
  2. Sous le plafond, total_results reste une estimation. Ne vous y fiez pas pour arrêter la pagination : continuez tant que les pages sont pleines et arrêtez-vous à la première page de moins de 25 résultats.

Découper les requêtes pour dépasser 10 000 résultats

La solution consiste à diviser une requête trop large en sous-requêtes qui tiennent chacune sous les 10 000 résultats, puis à fusionner. Trois dimensions s'y prêtent bien :

  • le département (la liste des codes valides est renvoyée par l'API si vous en passez un invalide) ;
  • l'état administratif : A puis C ;
  • la tranche d'effectif : les 16 valeurs couvrent toutes les entreprises, NN compris.

Exemple réel : les entreprises actives du code 70.22Z (conseil pour les affaires et autres conseils de gestion) ayant un établissement dans le Rhône dépassent le plafond. Hors entrepreneurs individuels, comme dans le script, total_results vaut 10 000, mais la seule tranche NN en compte 8 383 et passe sous la limite.

Comme le filtre departement porte sur n'importe quel établissement, une même entreprise peut apparaître dans plusieurs sous-requêtes. Il faut donc dédupliquer par SIREN.

Le script ci-dessous (Python 3, bibliothèque standard uniquement) applique ces règles : il découpe récursivement quand une requête atteint 10 000 résultats, pagine jusqu'à la page courte, se limite à 4 requêtes par seconde, attend en cas de 429 et écrit un CSV au séparateur point-virgule, lisible directement dans Excel.

"""Exporte en CSV les entreprises de l'API Recherche d'entreprises, au-delà de 10 000 résultats.

Usage : python export_sirene.py --naf 70.22Z --dep 69 --etat A --out conseil-69.csv
"""
import argparse, csv, json, time, urllib.error, urllib.parse, urllib.request

API = "https://recherche-entreprises.api.gouv.fr/search"
UA = "MonExport/1.0 (contact@example.com)"  # mettez un contact réel
PER_PAGE, CAP = 25, 10_000
TRANCHES = ["NN", "00", "01", "02", "03", "11", "12", "21", "22",
            "31", "32", "41", "42", "51", "52", "53"]
DEPARTEMENTS = [f"{i:02d}" for i in range(1, 96) if i != 20] + ["2A", "2B"] + \
    ["971", "972", "973", "974", "975", "976", "977", "978", "984", "986", "987", "988", "989"]


def get(params, page):
    query = dict(params, page=page, per_page=PER_PAGE, minimal="true", include="siege",
                 est_entrepreneur_individuel="false")
    url = API + "?" + urllib.parse.urlencode(query)
    for attempt in range(5):
        time.sleep(0.25)  # 4 requêtes par seconde au plus (limite : 7)
        try:
            req = urllib.request.Request(url, headers={"User-Agent": UA})
            with urllib.request.urlopen(req, timeout=30) as r:
                return json.load(r)
        except urllib.error.HTTPError as e:
            if e.code == 429 or e.code >= 500:
                time.sleep(int(e.headers.get("Retry-After") or 2 ** attempt))
                continue
            raise
    raise RuntimeError(f"Abandon après 5 essais : {url}")


def split_options(params):
    """Prochaine dimension de découpage : département, état, puis tranche d'effectif."""
    if "departement" not in params:
        return [dict(params, departement=d) for d in DEPARTEMENTS]
    if "etat_administratif" not in params:
        return [dict(params, etat_administratif=e) for e in ("A", "C")]
    if "tranche_effectif_salarie" not in params:
        return [dict(params, tranche_effectif_salarie=t) for t in TRANCHES]
    return []


def export(params, seen, writer, stats):
    first = get(params, 1)
    stats["requetes"] += 1
    children = split_options(params)
    if first["total_results"] >= CAP and children:
        for child in children:
            export(child, seen, writer, stats)
        return
    page, data = 1, first
    while True:
        for e in data["results"]:
            if e["siren"] in seen:
                continue
            seen.add(e["siren"])
            s = e.get("siege") or {}
            writer.writerow([e["siren"], s.get("siret"), e.get("nom_raison_sociale"),
                             e.get("activite_principale"), e.get("nature_juridique"),
                             e.get("tranche_effectif_salarie"), e.get("date_creation"),
                             e.get("etat_administratif"), s.get("code_postal"),
                             s.get("libelle_commune"), s.get("departement")])
        if len(data["results"]) < PER_PAGE:
            return
        if page * PER_PAGE >= CAP:  # fenêtre de 10 000 pleine
            if children:
                for child in children:
                    export(child, seen, writer, stats)
            else:
                print("Attention : plus de 10 000 résultats non découpables :", params)
            return
        page += 1
        data = get(params, page)
        stats["requetes"] += 1


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--naf", required=True, help="code NAF, ex. 62.01Z")
    ap.add_argument("--dep", help="code département, ex. 69 (tous si absent)")
    ap.add_argument("--etat", choices=["A", "C"], help="A = actives, C = cessées")
    ap.add_argument("--out", default="entreprises.csv")
    args = ap.parse_args()
    params = {"activite_principale": args.naf}
    if args.dep:
        params["departement"] = args.dep
    if args.etat:
        params["etat_administratif"] = args.etat
    seen, stats = set(), {"requetes": 0}
    with open(args.out, "w", newline="", encoding="utf-8-sig") as f:
        w = csv.writer(f, delimiter=";")
        w.writerow(["siren", "siret_siege", "nom", "naf", "nature_juridique",
                    "tranche_effectif", "date_creation", "etat", "code_postal",
                    "commune", "departement_siege"])
        export(params, seen, w, stats)
    print(f"{len(seen)} entreprises, {stats['requetes']} requêtes -> {args.out}")

Lors de notre test (--naf 70.22Z --dep 69 --etat A), le script a écrit 11 396 entreprises distinctes en 466 requêtes, en quelques minutes (de 3 à 6 lors de nos essais), alors qu'une requête simple s'arrête à 10 000. Parmi elles, 9 741 ont leur siège dans le Rhône : filtrez la colonne departement_siege si seul le siège compte pour vous.

Deux limites à connaître. Une combinaison département + état + tranche qui dépasse encore 10 000 résultats ne peut plus être découpée par ce script : il l'exporte jusqu'au plafond et affiche un avertissement (ajoutez alors nature_juridique comme quatrième dimension). Et pensez aux données personnelles : le script exclut les entrepreneurs individuels et ne récupère ni dirigeants ni adresses, mais certaines sociétés portent le nom de leur fondateur. Ne gardez que ce dont vous avez besoin.

Sans code et gratuit : l'outil « Constituer une liste »

Avant de lancer un script, regardez l'outil officiel Constituer une liste de l'Annuaire des Entreprises. Il fonctionne dans le navigateur, sans compte, et télécharge un CSV. On y choisit notamment :

  • les codes NAF et la zone (département, région, commune ou code postal) ;
  • la tranche d'effectif, la catégorie d'entreprise et la catégorie juridique ;
  • la date de création et l'état (actives, cessées ou les deux) ;
  • tous les établissements ou les seuls sièges.

Le fichier contient une ligne par établissement (ou par siège, si vous ne gardez que les sièges), et un export est limité à 200 000 lignes : la limite figure dans le code source ouvert du site. Pour une liste ponctuelle, c'est souvent la solution la plus simple. Pensez à choisir vos catégories juridiques si vous voulez écarter les entrepreneurs individuels.

Automatiser l'export et suivre les nouvelles entreprises : notre Actor Apify

Si vous voulez un export planifiable sans maintenir de script, Quarrywise publie sur l'Apify Store l'Actor SIRENE API: Export French Company Lists by NAF Code. Il lit la même API Recherche d'entreprises et fait le travail décrit plus haut, avec quelques précautions de plus :

  • au-delà de 10 000 résultats : la requête est découpée par état, tranche d'effectif, forme juridique, activité et département, puis dédupliquée par SIREN ;
  • siège dans le département par défaut, au lieu de « n'importe quel établissement » ;
  • pas de clé INSEE : il vous faut seulement un compte Apify ;
  • CSV, JSON ou Excel : une ligne par entreprise avec SIREN, SIRET du siège, nom, code et libellé NAF, forme juridique, tranche d'effectif, date de création, état, code postal et commune ;
  • flux des nouvelles entreprises : en mode « nouvelles entreprises » (newSinceLastRun) avec un identifiant de suivi, à planifier, chaque exécution ne renvoie que les entreprises apparues depuis la précédente ;
  • filtres de confidentialité : ni entrepreneurs individuels, ni dirigeants, ni adresse postale par défaut, et les sociétés qui portent le nom d'une personne sont écartées par un contrôle du nom (au mieux, sans garantie).

Exemple d'entrée :

{
    "nafCodes": ["62.01Z"],
    "departments": ["75", "92"],
    "status": "active",
    "mode": "export",
    "maxResults": 5000
}

Ses limites, décrites dans sa documentation : le filtre de date de création s'applique après lecture et n'accélère donc pas l'exécution, et une combinaison très dense que l'on ne peut plus découper est lue jusqu'à 10 000 résultats, avec un avertissement. La facturation se fait à la ligne exportée : 0,0025 $ par entreprise, au même prix sur tous les plans d'Apify, et 0,005 $ par exécution du flux des nouvelles entreprises, plus le petit coût de démarrage standard d'Apify à chaque exécution. L'Actor est un outil indépendant, sans lien avec l'INSEE ni la DINUM.

Si le script de cet article ou l'outil officiel vous suffisent, ils sont gratuits : la source publique est la même.

Quelle option choisir ?

  • Une liste ponctuelle, sans code : l'outil officiel « Constituer une liste », jusqu'à 200 000 lignes.
  • Quelques recherches par SIREN ou SIRET : l'API Recherche d'entreprises avec curl, sans clé.
  • Toutes les données Sirene diffusibles, établissements compris : l'API Sirene de l'INSEE avec une clé, ou les fichiers stock mensuels sur data.gouv.fr.
  • Une liste d'entreprises par code NAF et département, au-delà de 10 000, dans votre code : le script ci-dessus.
  • Un export planifié ou un suivi des nouvelles entreprises : l'Actor.

Dans tous les cas, citez la source quand vous republiez les données, par exemple : « Source : données Sirene (INSEE) et RNE via l'API Recherche d'entreprises, Licence Ouverte 2.0 », avec la date de mise à jour.

Sources