# SIRENE API: Export French Company Lists by NAF Code (`quarrywise/sirene-api-company-export`) Actor

SIRENE API without an INSEE key: export French company lists by NAF code, department, headcount, legal form and creation date, past the 10,000-result limit, or get a weekly feed of new companies. No sole proprietors, no directors, no emails or phone numbers.

- **URL**: https://apify.com/quarrywise/sirene-api-company-export.md
- **Developed by:** [Quarrywise](https://apify.com/quarrywise) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 company rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## SIRENE API: Export French Company Lists by NAF Code

Get clean lists of **French companies** from the SIRENE register in minutes: filter by **code NAF
/ APE**, **département**, **employee headcount**, **legal form**, **creation date** and **status**,
and download one tidy row per company with its **SIREN**, head-office **SIRET**, legal name,
activity label, size and location. Exports go **past the 10,000-result limit** of the source
automatically, and the **new-company feed** mode returns only the companies that appeared since
your last run. An independent tool built on the open API Recherche d'entreprises, which serves
SIRENE data: not affiliated with INSEE or DINUM, and no INSEE API key needed.

Built for privacy from the start: **no sole proprietors, no directors or birth dates, no emails or
phone numbers**. Companies named after a person are filtered out by a name check (best effort), and
street addresses are only included when you ask for them.

### SIRENE API for French company lists (API Sirene alternative, no INSEE key)

Call this Actor like an API: send filters, get a JSON, CSV or Excel list of companies back, with no
INSEE account, no API key and no 10,000-result ceiling.

#### Who it is for

- **B2B sales and marketing teams selling into France** who need target-account lists by sector
  (NAF code), region and company size.
- **Agencies, accountants and consultants** prospecting newly created companies in their area.
- **Developers and data teams** feeding a CRM, a data warehouse or an AI agent with an up-to-date
  French company reference (entreprises France, SIREN / SIRET lookups by sector).
- **Market researchers** counting and profiling companies by activity, legal form and size.

#### What you can do

- **Bulk export**: every company that matches your filters, for example all active software
  companies (NAF 62.01Z) headquartered in Paris, or all engineering firms (71.12B) in five
  departments. Large exports are split into smaller queries behind the scenes and de-duplicated by
  SIREN, so you are not stuck at 10,000 results.
- **New-company feed**: give the feed a watch ID and schedule it. Each run returns only companies
  that were not in the previous run with the same watch ID, marked `change_type: "new"`.
- **Filter by creation date**: a fixed date (`2026-01-01`) or a rolling window (`30 days`,
  `6 months`) to focus on recently created companies.
- **Coarse location by default**: postcode, commune, department and region of the head office.
  Switch to full detail to add the street address and coordinates.

### Export by code NAF, département and creation date (liste des entreprises par code NAF)

1. Pick one or more **NAF codes** (or a two-digit division such as `62`) and **departments**.
2. Optionally narrow by headcount bracket, legal form, creation date or status. Creation-date
   filters need at least one NAF code or department.
3. Choose **Export** for a one-off list, or **New-company feed** with a watch ID for a recurring
   list, and set **Maximum companies** to cap the run and its cost.
4. Run, then download the dataset or read it through the API.

#### Input example

```json
{
    "nafCodes": ["62.01Z", "62.02A"],
    "departments": ["75", "92"],
    "headcountBrackets": ["11", "12", "21"],
    "status": "active",
    "createdFrom": "5 years",
    "mode": "export",
    "addressDetail": "communeOnly",
    "maxResults": 5000
}
```

#### Input fields

| Field | What it does | Default |
| --- | --- | --- |
| `nafCodes` | NAF rev. 2 activity codes such as `62.01Z`; a two-digit division such as `62` includes every code in it | all activities |
| `departments` | INSEE department codes such as `75`, `2A`, `974` | all of France |
| `headcountBrackets` | INSEE employee brackets (`NN`, `00`, `01` ... `53`) | all sizes |
| `legalCategories` | INSEE legal categories such as `5710` (SAS), `5499` (SARL), `5599` (SA), `6540` (SCI) | all company forms |
| `createdFrom`, `createdTo` | Creation date range: `YYYY-MM-DD` or a period back from today such as `30 days`; needs a NAF code or department | no limit |
| `status` | `active`, `ceased` or `any` | `active` |
| `locationMatch` | `headOffice`: head office in the departments. `anyEstablishment`: any establishment there | `headOffice` |
| `mode` | `export` or `newSinceLastRun` (new-company feed) | `export` |
| `watchId` | Name of the feed; runs with the same watch ID are compared | required for the feed |
| `outputOnFirstRun` | Feed only: output the current companies on the first run, or only record a baseline | `true` |
| `addressDetail` | `communeOnly` or `full` (adds street address, latitude, longitude) | `communeOnly` |
| `maxResults` | Stop output after this many company rows (feed: new companies) | 1,000 |

### Use it from n8n, Make, Zapier or an AI agent

- **n8n:** add Apify's verified n8n node (`@apify/n8n-nodes-apify`; on n8n Cloud the instance owner
  first enables verified community nodes). Use the operation "Run an Actor and Get Dataset" and
  select this Actor By URL (enter exactly
  `https://console.apify.com/actors/gYAJJzq3P2PXzpfa3/input`) or by ID (`gYAJJzq3P2PXzpfa3`); the
  From list picker may not show it while the Actor is hidden from Store search. The Actor's Store
  page URL does not work in the By URL field. Then paste the same JSON input.
  For a weekly feed of new companies, put a Schedule Trigger in front and use mode
  `newSinceLastRun` with a `watchId`.
- **Make:** Apify's app: the "Run an Actor" module, then "Get Dataset Items" and add the rows to
  Google Sheets, Airtable or your CRM (the "Watch Actor Runs" trigger fires when a run finishes).
- **Zapier:** Apify's app: the "Run Actor" action, then "Fetch dataset items" (the "Finished
  Actor run" trigger fires when a run finishes).
- **AI agents (MCP clients):** add this Actor as a tool through Apify's MCP server:
  `https://mcp.apify.com?tools=quarrywise/sirene-api-company-export`
  The MCP server needs an Apify sign-in or API token.
- **API:** `POST https://api.apify.com/v2/acts/quarrywise~sirene-api-company-export/run-sync-get-dataset-items`
  with your Apify token in the `Authorization: Bearer` header and the input JSON as the body.
  The call waits at most 300 seconds (HTTP 408 after that); for longer runs start the Actor
  asynchronously and read the dataset when it finishes.

### Fichier entreprises: CSV, JSON or Excel output

Every run fills a dataset with one row per company. Download it from the run page as **CSV, Excel,
JSON, XML or HTML**, or fetch it from the dataset API endpoint in any of those formats, so the same
run gives you a spreadsheet-ready company file (fichier entreprises) or a JSON feed for your code.
Large exports page through the dataset API like any other Apify dataset.

### New companies feed (nouvelles entreprises créées) since your last run

New-company feed, for a weekly schedule:

```json
{
    "mode": "newSinceLastRun",
    "watchId": "lyon-software",
    "nafCodes": ["62"],
    "departments": ["69"],
    "outputOnFirstRun": false,
    "maxResults": 2000
}
```

- With `outputOnFirstRun` off, the first run only records the current companies as a baseline and
  outputs nothing (and charges no rows); every later run outputs the companies that are new since
  the previous one.
- With `outputOnFirstRun` on, the first run outputs the current companies as well. If it stops at
  **Maximum companies** or at your maximum charge, it still reads the rest of the scope and records
  those companies as the baseline without output or charge, and says so in the run summary. Later
  runs therefore never report an old company as new.
- Add `createdFrom: "30 days"` if you only want companies that were also created recently.

### Output fields

One row per company. Example (from a real run, NAF 62.01Z in Paris):

```json
{
    "siren": "849239587",
    "siret_hq": "84923958700199",
    "name": "SNAPDESK",
    "naf_code": "62.01Z",
    "naf_label": "Programmation informatique",
    "legal_form_code": "5710",
    "legal_form": "SAS, société par actions simplifiée",
    "category": "PME",
    "headcount_bracket": "11",
    "headcount_label": "10 à 19 salariés",
    "headcount_year": "2024",
    "created_on": "2019-03-15",
    "status": "active",
    "closed_on": null,
    "establishments_open": 19,
    "postcode": "75010",
    "commune": "PARIS",
    "commune_code": "75110",
    "department": "75",
    "department_name": "Paris",
    "region": "11",
    "region_name": "Île-de-France",
    "address": null,
    "latitude": null,
    "longitude": null,
    "change_type": null,
    "first_seen": null,
    "updated_on": "2026-10-25",
    "source_url": "https://recherche-entreprises.api.gouv.fr/search?q=849239587",
    "retrieved_at": "2026-10-25T23:03:46.653Z"
}
```

| Field | Meaning |
| --- | --- |
| `siren`, `siret_hq` | Company number and head-office establishment number |
| `name` | Registered legal name |
| `naf_code`, `naf_label` | Main activity (NAF rev. 2) and its French label |
| `legal_form_code`, `legal_form` | INSEE legal category and its label |
| `category` | INSEE size category: PME, ETI or GE |
| `headcount_bracket`, `headcount_label`, `headcount_year` | Employee bracket, its label and reference year |
| `created_on`, `status`, `closed_on` | Creation date, `active` or `ceased`, closure date |
| `establishments_open` | Number of open establishments |
| `postcode`, `commune`, `commune_code`, `department`, `department_name`, `region`, `region_name` | Head-office location |
| `address`, `latitude`, `longitude` | Head-office street address (number, street, postcode, commune) and coordinates, only with `addressDetail: "full"` |
| `change_type`, `first_seen` | `new` and the time first seen, in the new-company feed |
| `updated_on` | Date INSEE last updated the company in the Sirene register, for the licence attribution (if the source gives no INSEE date, the record's last update date in the source API) |
| `source_url`, `retrieved_at` | Where and when the data was retrieved |

The run summary (counts of fetched, excluded and saved companies, query splits, warnings and the
source attribution) is saved in the key-value store record `OUTPUT`. If the source stops the run
(for example by rate limiting), a free row with `error: true` explains why instead of a silent
failure.

### What is not included (no managers, no sole traders, no emails)

- **Sole proprietors** (entrepreneurs individuels, legal category 1000) and **groups of private
  individuals** (indivisions, 2110): they are natural persons. This is enforced in code, not a
  setting you can switch off.
- **Companies named after a person**, filtered by a name check: a legal name that is a director's
  first and last name, a common first name next to a surname, or a common French surname with only
  legal-form or trade words around it (for example "SCI" plus a frequent family name). This is
  best effort: a company named after a rare family name, with no director listed, can still appear.
- **Partly public units** (INSEE partial publication status).
- **Directors (dirigeants), their names, birth years and nationality**: the source returns them,
  the Actor uses them only to detect person-named companies and never outputs them.
- **Emails, phone numbers and contact names**: SIRENE does not contain them, and we do not add them.
- **Street addresses and coordinates by default**: many small companies are registered at a home
  address, so the default output stops at postcode and commune. Full detail builds the street
  address from the register's number, street, postcode and commune only; the free-text address
  complement (which can read "chez" plus a person's name) is never output.

### Pricing per company row

Pay per event: you pay for each company row saved to your dataset, nothing for companies that
were filtered out, skipped or excluded.

| Event | Price |
| --- | --- |
| Company row (`company-row`) | $0.0025 |
| New-company feed run (`watch-run`), once per feed run | $0.005 |

Plus Apify's standard Actor start event, a fraction of a cent per run. There are no free-tier
limits: every plan gets every feature at the same prices.

Example costs:

| Run | Rows | Cost |
| --- | --- | --- |
| Quick test with the default prefill | 50 | about $0.13 |
| A 1,000-company export (the default maximum) | 1,000 | $2.50 |
| A 10,000-company export | 10,000 | $25 |
| Weekly new-company feed that finds 40 new companies | 40 | $0.105 |

Set **Maximum companies** or a maximum charge per run to cap what a run can cost; the run stops
cleanly at that limit and you only pay for rows that were saved.

### Data source, licence and attribution

The data comes from the French administration's open company search API
(`recherche-entreprises.api.gouv.fr`, run by DINUM), which serves the INSEE Sirene register (base
Sirene) together with data from the RNE (Registre national des entreprises, kept by INPI). Sirene
data is published under the **Licence Ouverte / Open Licence 2.0** (Etalab), which allows
commercial reuse provided the source (at least the licensor's name) and the date of its last
update are credited, without suggesting that a public body endorses the reuse. The RNE data has
its own licence from INPI. The rows this Actor outputs are Sirene fields only: the directors the
API returns are read only to leave out companies named after a person and are never part of a
row. Attribution to use when you republish the data:

> Source: Insee, base Sirene, via l'API Recherche d'entreprises (DINUM, data.gouv.fr), Licence
> Ouverte 2.0, data last updated on the date in `updated_on` (retrieved on `retrieved_at`).

Companies that asked INSEE not to publish their data (non-diffusible units) are already removed
by the source. This Actor is independent and is not affiliated with or endorsed by INSEE, DINUM,
INPI or any French administration.

What we verified on the live source (October 2026): it needs no key or login; it returns at most
25 results per page and 10,000 results per query, which is why large exports are split; it allows
7 requests per second per IP, and this Actor stays at 5 or fewer, identifies itself, checks
robots.txt and text-and-data-mining reservations (TDMRep), backs off when asked to slow down and
stops if it is refused; it has no creation-date filter, so creation dates
are filtered after fetching; and its result counts are estimates (one query announced 7,968
companies and returned 7,922, another announced 4,111 and returned 4,125), so the Actor pages
until the results run out instead of trusting the count. In a live test over ten departments it
read 27,323 distinct companies where the source's own counts added up to 27,328.

### Limitations

- **Creation-date filters do not speed up a run.** The source cannot filter by creation date, so
  the Actor reads everything else that matches and filters dates itself. You only pay for the rows
  that pass. Date filters therefore need a NAF code or department, and an export stops after
  reading 50 pages per requested row (at least 2,000 pages) and says so in the summary.
- **The department filter of the source matches any establishment.** By default the Actor keeps
  only companies whose head office is in your departments, so it may read more pages than the
  number of rows you get.
- **The new-company feed re-reads its whole scope on every run** (the source has no "changed
  since" filter). Keep each feed focused (a few NAF codes and departments); one watch remembers up
  to 100,000 companies, and a run that would go past that stops before charging for rows it could
  not remember.
- **Very dense combinations** (one NAF code, one department, one headcount bracket, one legal form
  with more than 10,000 companies) cannot be split further; the run then reads the first 10,000 and
  says so in the summary. This is rare outside the largest categories.
- **Ceased companies past 10,000 per query may be incomplete.** Many ceased companies carry a NAF
  code from before 2008 or no legal category, and the queries used to split past 10,000 results
  cannot match them. The Actor also reads the first 10,000 results of such a query directly and
  warns in the summary, but companies of that kind beyond those can be missing. Active companies
  are not affected in practice.
- **Some trade names that look like a person's name are left out too.** Small companies whose name
  contains a common first name next to other words, or a frequent family name with only legal-form
  or trade words, are excluded to protect founders' privacy; a few genuine trade names are caught
  by these rules. In a 27,000-company test the first-name rule removed well under 1% of companies;
  in a 3,519-company test the surname rule removed another 7 (0.2%).
- Headcount brackets and size categories are INSEE's latest published values and can be a year or
  two old.

### FAQ: base Sirene, API Siren, API Siret

**Is this the INSEE API Sirene? Do I need an INSEE key?**
No and no. This is an independent Actor that reads the open API Recherche d'entreprises, which
serves the same SIRENE register (base Sirene) together with RNE data. It needs no INSEE account or
API key; you only need an Apify account.

**Is this a download of the whole base Sirene (fichier Sirene)?**
It is a filtered extract: you choose the activities, departments and other filters, and get the
matching companies as a file. The full monthly base Sirene files from INSEE are much larger and
include sole proprietors and establishments, which this Actor leaves out.

**Can I get SIRET numbers for a whole sector?**
Yes: every row has the SIREN (API Siren) and the head-office SIRET (API Siret) of the company.
Choose the NAF codes of the sector, leave departments empty for all of France and set a high
maximum. Only head-office establishments are included, one row per company.

**Can I export all companies in France for a NAF code, beyond 10,000 results?**
Yes. Leave departments empty and set a high maximum; the Actor splits the query by status,
headcount, legal form, activity and department until each part fits, and removes duplicates. For
ceased companies, see the limitation above.

**How do I get only new companies every week?**
Use `mode: "newSinceLastRun"` with a watch ID and schedule the Actor weekly. Add
`createdFrom: "30 days"` if you only want companies that were also created recently.

**Why are some companies from my department missing?**
Check `locationMatch`: by default only head offices count. Sole proprietors are never included, and
companies named after a person are filtered out.

**Can I get the street address?**
Yes, set `addressDetail` to `full`. Use it only when you need it: small companies often use a
home address.

**Is the data current?**
Each run reads the live source; `retrieved_at` shows when, and `updated_on` shows when INSEE
last updated each company in the Sirene register. The source is updated continuously from INSEE and the RNE: records we
checked had been updated the same day.

**What happens if the source is down or rate limits the run?**
The Actor waits and retries politely. If the source keeps refusing, the run ends with a free
error row and a summary instead of failing silently.

### Changelog

See the Changelog tab. Version 0.1 (October 2026): first release with bulk export, automatic
query splitting, the new-company feed, privacy exclusions and coarse addresses by default.

### Provider

Provided by Quarrywise, a trade name of Picazzo Research & Development, Zinkstraat 24, Box C4687, 4823 AD Breda, the Netherlands. KvK 42060545, VAT NL005464235B85. Contact: hello@quarrywise.com or the Issues tab.

# Changelog

This Actor's version history is a separate document: https://apify.com/quarrywise/sirene-api-company-export/changelog.md

# Actor input Schema

## `nafCodes` (type: `array`):

NAF rev. 2 codes of the company's main activity, for example 62.01Z (computer programming). You can also type a two-digit division such as 62 to include every code in it. Leave empty for all activities.

## `departments` (type: `array`):

French departments (INSEE codes such as 75, 69, 2A, 974). By default a company matches when its head office is in one of them; see "Location match" below. Leave empty for all of France.

## `headcountBrackets` (type: `array`):

INSEE headcount brackets of the company (latest year published). Leave empty for all sizes.

## `legalCategories` (type: `array`):

INSEE legal categories, for example 5710 (SAS), 5499 (SARL), 5599 (SA) or 6540 (SCI). Sole proprietors (1000) and groups of private individuals (2110) are never exported and cannot be selected. Leave empty for all.

## `createdFrom` (type: `string`):

Only companies created on or after this date: a date (YYYY-MM-DD) or a period back from today such as "30 days" or "6 months". Needs at least one NAF code or department. The source has no date filter, so this is applied after fetching: it narrows the output (and what you pay for), not the run time.

## `createdTo` (type: `string`):

Only companies created on or before this date (YYYY-MM-DD, or a period back from today such as "1 year"). Needs at least one NAF code or department.

## `status` (type: `string`):

Active companies only (default), ceased companies only, or both.

## `locationMatch` (type: `string`):

How the department filter applies. "Head office" keeps companies whose registered head office is in the departments. "Any establishment" also keeps companies headquartered elsewhere that have an establishment there (the output still shows the head office).

## `mode` (type: `string`):

Export: every company that matches the filters, up to the maximum. New-company feed: only companies that were not in the previous run with the same watch ID (schedule it daily or weekly).

## `watchId` (type: `string`):

Required for the new-company feed: a name for this feed, for example "paris-software". Runs with the same watch ID are compared with each other. Letters, digits, ".", "\_" and "-" only, up to 64 characters.

## `outputOnFirstRun` (type: `boolean`):

New-company feed only. On, the first run of a watch outputs every matching company (charged per row) and remembers them. Off, the first run only records the current companies as a baseline and outputs nothing, so later runs return genuinely new companies only.

## `addressDetail` (type: `string`):

Commune only (default): postcode, commune, department and region of the head office. Full: also the street address (number, street, postcode and commune from the register, without the free-text address complement) and coordinates. Small companies are often registered at a home address, so use full detail only when you need it.

## `maxResults` (type: `integer`):

Stop after this many company rows (in the feed: new companies). Each row is charged, so this also caps the cost. You can also set a maximum charge per run in the run options.

## Actor input object example

```json
{
  "nafCodes": [
    "62.01Z"
  ],
  "departments": [
    "75"
  ],
  "status": "active",
  "locationMatch": "headOffice",
  "mode": "export",
  "outputOnFirstRun": true,
  "addressDetail": "communeOnly",
  "maxResults": 50
}
```

# Actor output Schema

## `results` (type: `string`):

One row per company: SIREN, head-office SIRET, legal name, NAF code and label, legal form, size, creation date, status and head-office location.

## `summary` (type: `string`):

Counts of fetched, excluded and saved companies, query splits, warnings and the source attribution.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "nafCodes": [
        "62.01Z"
    ],
    "departments": [
        "75"
    ],
    "mode": "export",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("quarrywise/sirene-api-company-export").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "nafCodes": ["62.01Z"],
    "departments": ["75"],
    "mode": "export",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("quarrywise/sirene-api-company-export").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "nafCodes": [
    "62.01Z"
  ],
  "departments": [
    "75"
  ],
  "mode": "export",
  "maxResults": 50
}' |
apify call quarrywise/sirene-api-company-export --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,quarrywise/sirene-api-company-export"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gYAJJzq3P2PXzpfa3/builds/QhyykMR54VlYDOeEw/openapi.json