# Datele unei firme după CUI, din cod: PHP, Python, JavaScript, Google Sheets, Excel

Toate exemplele cer datele firmei cu CUI-ul `13548146`. Îți trebuie o cheie API, pe care o creezi în [cont](/cont); contul este gratuit. Cheia se trimite în antetul `Authorization: Bearer ...`, iar în exemple este luată din variabila de mediu `APIFIRME_API_KEY`.

Nu pune cheia într-o pagină web sau într-o aplicație pe care o descarcă alții: oricine o vede o poate folosi. Ține-o pe server. O cheie scăpată o revoci în cont și îți faci alta.

## Ce răspunsuri să tratezi

| Cod | Ce înseamnă și ce faci |
|---|---|
| `200` | Datele firmei, în JSON. |
| `202` | Firma nu era încă la noi și este căutată chiar acum la ANAF. Repetă cererea după câte secunde spune antetul `Retry-After`; nu se numără. |
| `404` | Nu există un contribuabil cu acest CUI. |
| `400` | CUI-ul nu este valid; `detail` spune de ce. |
| `401` | Cheia lipsește sau nu este bună. |
| `429` | Ai trecut de limita pe minut sau de cererile lunii; antetul `Retry-After` spune cât aștepți. Nu se numără. |

Erorile au corpul în formatul RFC 7807: `title` și `detail` spun ce s-a întâmplat.

## curl

```
curl https://api.apifirme.dev/rest/v1/companies/13548146 \
  -H "Authorization: Bearer $APIFIRME_API_KEY"
```

## PHP

Cu extensia curl, din PHP 7.4 încoace:

```
<?php
// APIFIRME_API_KEY=af_live_... php firma.php
function apifirme(string $path): array
{
    for ($attempt = 1; $attempt <= 5; $attempt++) {
        $retryAfter = 1;
        $ch = curl_init('https://api.apifirme.dev/rest/v1/' . $path);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => 30,
            CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . getenv('APIFIRME_API_KEY')],
            CURLOPT_HEADERFUNCTION => function ($ch, $header) use (&$retryAfter) {
                if (stripos($header, 'Retry-After:') === 0) {
                    $retryAfter = max(1, (int) trim(substr($header, 12)));
                }
                return strlen($header);
            },
        ]);
        $body = curl_exec($ch);
        $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

        // 202: the company is being fetched from ANAF; ask again shortly.
        if ($status !== 202) {
            return [$status, json_decode((string) $body, true)];
        }
        sleep($retryAfter);
    }
    return [$status, null];
}

[$status, $company] = apifirme('companies/13548146');

if ($status === 200) {
    echo $company['denumire'], ' | ', $company['stare'], ' | VAT: ', var_export($company['scp_tva'], true), PHP_EOL;
} else {
    echo 'Error ', $status, ': ', $company['detail'] ?? '', PHP_EOL;
}
```

## Python

Cu biblioteca `requests`:

```
# APIFIRME_API_KEY=af_live_... python3 firma.py
import os
import time

import requests

API = "https://api.apifirme.dev/rest/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['APIFIRME_API_KEY']}"}


def apifirme(path, payload=None):
    for _ in range(5):
        if payload is None:
            response = requests.get(f"{API}/{path}", headers=HEADERS, timeout=30)
        else:
            response = requests.post(f"{API}/{path}", headers=HEADERS, json=payload, timeout=30)
        # 202: the company is being fetched from ANAF; ask again shortly.
        if response.status_code != 202:
            return response
        time.sleep(int(response.headers.get("Retry-After", "1")))
    return response


response = apifirme("companies/13548146")

if response.status_code == 200:
    company = response.json()
    print(company["denumire"], "|", company["stare"], "| VAT:", company["scp_tva"])
else:
    print("Error", response.status_code, response.json().get("detail"))
```

## JavaScript (Node.js)

Cu `fetch`, din Node.js 18 încoace, într-un fișier `.mjs`:

```
// APIFIRME_API_KEY=af_live_... node firma.mjs
const API = "https://api.apifirme.dev/rest/v1";

async function apifirme(path) {
  for (let attempt = 1; ; attempt++) {
    const response = await fetch(`${API}/${path}`, {
      headers: { Authorization: `Bearer ${process.env.APIFIRME_API_KEY}` },
    });
    // 202: the company is being fetched from ANAF; ask again shortly.
    if (response.status !== 202 || attempt === 5) return response;
    const seconds = Number(response.headers.get("Retry-After")) || 1;
    await new Promise((resolve) => setTimeout(resolve, seconds * 1000));
  }
}

const response = await apifirme("companies/13548146");
const body = await response.json();

if (response.ok) {
  console.log(body.denumire, "|", body.stare, "| VAT:", body.scp_tva);
} else {
  console.log("Error", response.status, body.detail);
}
```

Din browser, cheia s-ar vedea în pagină: cererea se face de pe serverul tău, iar pagina îl întreabă pe el.

## Verificarea dinaintea facturării

Aceeași funcție, cu `invoice-check` în loc de `companies`. Răspunsul are doar ce trebuie pentru o factură: `valid_for_invoicing`, `vat_number`, `vat_on_collection`, `inactive`, `struck_off`, `efactura_registered`. În Python:

```
check = apifirme("invoice-check/13548146").json()

if not check["exists"]:
    print("No taxpayer with this CUI")
elif not check["valid_for_invoicing"]:
    print("Struck off or fiscally inactive:", check["stare"])
else:
    print("Invoice to", check["denumire"], check["vat_number"] or "(not VAT-registered)")
```

Ce înseamnă fiecare câmp: [verificarea unei firme după CUI](/verificare-cui#inainte-de-a-emite-o-factura).

## Mai multe firme deodată

`POST /rest/v1/companies/batch` primește până la 100 de CUI-uri și răspunde din ce este deja în baza de date: firmele în `data`, în ordinea cerută, iar în `not_stored` și `incomplete` CUI-urile pe care le ceri apoi singure (sunt căutate la ANAF). Fiecare firmă întoarsă se numără ca o cerere; pentru limita pe minut, toată cererea este una singură. În Python, cu funcția de mai sus:

```
result = apifirme("companies/batch", {"cuis": ["13548146", "RO4221306"]}).json()

for company in result["data"]:
    print(company["cui"], company["denumire"], company["stare"])

for cui in result["not_stored"] + result["incomplete"]:
    print(cui, apifirme(f"companies/{cui}").json().get("denumire"))

print("Not a valid CUI:", result["invalid"])
```

## Google Sheets

O funcție a ta în foaie: `=APIFIRME(A2)` pentru un CUI sau `=APIFIRME(A2:A101)` pentru o coloană întreagă, cu denumirea, starea și TVA-ul pe fiecare rând. O coloană de până la 100 de CUI-uri este o singură cerere `batch`; doar CUI-urile pe care nu le avem încă sunt cerute apoi câte unul.

- În foaie, deschide Extensii → Apps Script, șterge ce este acolo și lipește codul de mai jos, cu cheia ta în locul lui `af_live_...`. Salvează.
- Tot în editor, alege funcția `APIFIRME` și apasă Rulează (Run): Google îți cere o dată permisiunea ca scriptul să se conecteze la un serviciu extern. Rularea din editor nu face nicio cerere.
- Scrie în foaie `=APIFIRME(A2:A101)`, unde coloana A are CUI-urile.
- Foaia recalculează formula când se schimbă celulele ei, și fiecare calcul costă cereri. Când nu mai ai nevoie ca datele să se actualizeze, copiază rezultatul și lipește-l ca valori.
- Oricine poate edita foaia vede cheia din script. Fă-ți o cheie doar pentru foaie, pe care o poți revoca oricând.

```
const APIFIRME_API_KEY = "af_live_...";

/**
 * Name, state and VAT registration for one CUI or a column of up to 100.
 * @param {string|Array<Array<string>>} cuis A CUI or a range of CUIs.
 * @return The name, state and VAT registration, one row per CUI.
 * @customfunction
 */
function APIFIRME(cuis) {
  const rows = Array.isArray(cuis) ? cuis.map((row) => row[0]) : [cuis];
  const clean = (cui) => (cui == null ? "" : String(cui)).trim().toUpperCase().replace(/^RO\s*/, "");
  const asked = rows.map(clean).filter((cui) => cui !== "");
  if (asked.length === 0) return "";
  if (asked.length > 100) return "At most 100 CUIs at a time";

  const response = UrlFetchApp.fetch("https://api.apifirme.dev/rest/v1/companies/batch", {
    method: "post",
    contentType: "application/json",
    headers: { Authorization: "Bearer " + APIFIRME_API_KEY },
    payload: JSON.stringify({ cuis: asked }),
    muteHttpExceptions: true,
  });
  const body = JSON.parse(response.getContentText());
  if (response.getResponseCode() !== 200) return "Error: " + (body.detail || response.getResponseCode());

  const found = {};
  body.data.forEach((company) => (found[String(company.cui)] = company));

  // Not with us yet, or incomplete: asked for alone, which looks them up at ANAF.
  body.not_stored.concat(body.incomplete).forEach((cui) => {
    const one = UrlFetchApp.fetch("https://api.apifirme.dev/rest/v1/companies/" + cui, {
      headers: { Authorization: "Bearer " + APIFIRME_API_KEY },
      muteHttpExceptions: true,
    });
    if (one.getResponseCode() === 200) found[String(cui)] = JSON.parse(one.getContentText());
    if (one.getResponseCode() === 404) found[String(cui)] = null;
  });

  return rows.map((cui) => {
    if (clean(cui) === "") return ["", "", ""];
    if (body.invalid.map(String).includes(clean(cui))) return ["not a valid CUI", "", ""];
    const company = found[clean(cui)];
    if (company === null) return ["no taxpayer with this CUI", "", ""];
    if (company === undefined) return ["not available now, try again later", "", ""];
    return [company.denumire, company.stare, company.scp_tva ? "VAT" : "no VAT"];
  });
}
```

## Excel

Cu Power Query, din Excel 2016 sau Microsoft 365 pe Windows, fără nicio extensie. Numele de mai jos sunt cele din Excel în engleză; în română sunt traduse (Data → From Web este Date → Din web).

- Data → From Web, apoi alege Advanced.
- La URL parts scrie `https://api.apifirme.dev/rest/v1/companies/13548146`.
- La HTTP request header parameters alege sau scrie `Authorization`, iar alături `Bearer af_live_...`, cu cheia ta.
- Când Excel întreabă cum să se conecteze, alege Anonymous: cheia din antet este cea care contează.
- În Power Query apasă Into Table, apoi Close & Load.

Fișierul păstrează cheia: fă-ți o cheie doar pentru el, pe care o poți revoca. Pentru o coloană întreagă de CUI-uri, Google Sheets sau un program care cere `batch` merg mai bine decât câte o interogare pe firmă.

## Mai departe

- Toate cererile, parametrii și câmpurile: [documentația API](/docs), și descrierea OpenAPI 3.1 de la `https://api.apifirme.dev/openapi.json`, din care se pot genera clienți în orice limbaj.
- Firmele nou-înființate, cu filtre pe județ și cod CAEN: `GET /rest/v1/registrations`, descris în documentație; câte sunt și cele mai noi, la [firme nou-înființate](/firme-noi).
- Aceleași date direct în Claude, ChatGPT sau alt asistent AI, fără cod: [apifirme în asistentul tău AI](/ai).
- Planurile și limitele lor: [prețuri](/preturi).
