# EU Business Demography — Formation & Survival, Per Record (`nexgensignal/eu-business-demography-records`) Actor

Eurostat business demography (bd\_9bd\_sz\_cl\_r2) as clean, per-record formation and survival benchmarks — enterprise births, deaths, survival and active counts by size class, NACE Rev.2 industry and country. Licence-clean, $0.05 per record.

- **URL**: https://apify.com/nexgensignal/eu-business-demography-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 business demography records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## EU Business Demography — Formation & Survival, Per Record

Turn Eurostat's business-demography cube into clean, per-record company-formation and survival benchmarks — one row per published observation, broken down by business-demography indicator, enterprise size class, industry (NACE Rev.2) and country, ready to size company formation, death and survival across Europe.

Each row of the source multidimensional cube becomes **one clean, flat record**: every dimension is
expanded into an explicit code **and** its label, the observation value is reproduced exactly as Eurostat
published it, and each record is stamped with source, dataset code, licence, attribution, a UTC retrieval
timestamp and an interpretation caveat.

### What one record represents

The source dataset is Eurostat **`bd_9bd_sz_cl_r2`** — business demography by size class (NACE Rev.2): enterprise births, deaths, survival and active populations. Eurostat publishes it as a
JSON-stat hypercube indexed by several dimensions (frequency, business-demography indicator, size class, NACE Rev.2 activity, geography and time); this Actor unpacks it so **every
present observation cell becomes exactly one record**. Cells Eurostat does not publish are absent from
the source and are neither invented nor delivered; published zeros are kept as real values.

For each record you get a composite `record_id`, the `dataset_code`, the `indicator` name, then — for
each dimension — the code and its label, plus `time_period`, the numeric `value`, and Eurostat's
`obs_status` flag when present. The dimension columns include `indic_sb` (the business-demography indicator — active enterprises, births, deaths, survival counts and rates) with its label, `sizeclas` (enterprise size class), `nace_r2` (industry) and `freq`.

### Coverage and volume

Per licence-permitted territory the cube is large: Germany alone carries 501,603 non-null observations across the published years. Across all licence-permitted territories the full-cube capacity is **15,695,464** non-null observations spanning 2004-2020.

**Live full-cube allowed count is 15,695,464 records across 2004-2020 and all licence-permitted territories; the Wave-3 index figure of 1,234,612 reflects the 2020 single-year slice only. This README states the difference; the capacity line is the full-cube count.**

Because the full multi-territory cube exceeds the dissemination API's single-response size limit, this
Actor takes the **reporting country as a required input** (prefilled to `DE`), pulling one
territory at a time; the generalized ingester also auto-partitions on a size limit where needed and stops
at your **Maximum records** cap.

### Licence and attribution

This dataset is redistributed under the terms Eurostat publishes it with; the full notice travels on
every record in the `licence` field:

> Eurostat, CC BY 4.0. Reformatted from Eurostat JSON-stat; values unmodified. Third-party content and logos excluded. Commercial-barred geographies removed.

A structural **geography allow-list is applied at ingest**: only EU member states, EU/euro-area
aggregates, EFTA members and official EU acceding/candidate countries are delivered; commercial-barred
territories are excluded at ingest and counted in the run receipt. The required attribution —
`Source: Eurostat (dataset bd_9bd_sz_cl_r2)` — is on every record.

### Interpretation caveat

Business demography indicators (enterprise births, deaths, survival, active-enterprise populations and related rates) by size class and NACE Rev.2 activity. Counts are enterprise counts, not turnover or employment; read the `indic_sb` code to know which measure a row carries.

Eurostat values are reproduced verbatim: no rescaling, re-basing, interpolation or seasonal adjustment.
Read each value together with its dimension labels — the `indic_sb` code tells you which measure a row
carries.

### Person-data policy

This is a statistics product about enterprises, industries and territories. There are no natural-person
or contact fields anywhere in the record, and a per-record assertion enforces that allow-list at write
time.

### Provenance, licensing and compliance

Every run begins with a live source-preflight: the Actor reads the exact host's `robots.txt` at runtime
and refuses to proceed if the crawl policy disallows the data path. The gate result — URL, HTTP status,
byte length and a SHA-256 of the policy — is written to the run's `RUN_RECEIPT`, so each run carries its
own audit trail. The Actor identifies itself with a transparent, non-impersonating User-Agent and never
bypasses a block, solves a challenge, or fetches through a cache or mirror. When the door is genuinely
unavailable the run fails loudly and bills nothing.

### Inputs

- **Country / territory** (`geo`) — required; the Eurostat geo code to pull (e.g. `DE`). This
  cube is too large to return in one request, so it is retrieved one territory at a time.
- **Earliest period** (`sinceTimePeriod`) — return observations from this year onward. An earlier start
  yields more records.
- **Maximum records** (`maxRecords`) — hard cap on records delivered and billed.

### Output

Records land in the Actor's default dataset and export as JSON, CSV, Excel or via the Apify API. A
tabular **overview view** surfaces geography, period, the key dimension labels and the value.

### Fields in detail

Each record leads with a composite `record_id` built from every dimension code, so it is stable and
join-ready across runs. Every dimension arrives as both a machine code and a human-readable label, which
means you can group and filter on the codes while reading the labels — no separate code list to maintain.
The `value` is the observation itself, reproduced exactly; `obs_status` carries Eurostat's flag (for
example a break in series or a provisional marker) when one is present, so you never silently lose the
caveats Eurostat attaches to a number. The provenance block — `source`, `source_dataset`, `licence`,
`attribution`, `caveat`, `observed_at` — is present on every record, so each row is self-describing and
audit-ready without reference back to this page.

### Sibling Actors

This Actor sits alongside the fleet's **`national-macro-indicator-records`** cell — but that carries macro aggregates (headline national indicators), while this one is enterprise-level **business demography** (formation, death and survival by size and industry): a different grain and a different question. It also shares its engineering — the runtime robots gate, the geo allow-list, the
push-then-charge billing and the verbatim-value discipline — with the fleet's other Eurostat cells.

### Pricing

This Actor uses Apify's pay-per-event model: a flat **$0.05 per record** actually delivered to the
dataset, and nothing else — no monthly rental, no per-run base fee, no compute charge. Deliver 40
records and you pay $2.00; deliver 10,000 and you pay $500.00. Billing is wired *after* delivery — each
record is pushed first and only then does the per-record event fire — so a mid-run failure can only
ever under-charge you, never over-charge. Use **Maximum records** to cap spend precisely.

### Scaling and limits

Set **Maximum records** low to sample cheaply or high to pull a territory in full. The Actor streams the
cube and delivers incrementally, so memory stays bounded regardless of how large the requested territory
is, and you are billed only for records actually delivered. Because Eurostat updates this cube on its own
release calendar, re-running the Actor picks up new periods automatically, and each record's `observed_at`
stamp dates the snapshot — schedule a run to keep a downstream table current. To assemble a multi-country
panel, run the Actor once per territory and concatenate; every record already carries its `geo` code and
label, so the panels align without any reconciliation work.

### Typical uses

Size company formation and closure by country and industry; measure survival rates by cohort; compare small-firm versus large-firm dynamics; benchmark entrepreneurial activity across member states; or feed a strategy, credit-risk or market-entry model with clean, licence-clean business-demography inputs.

### What this Actor does not do

It does not forecast, model, seasonally adjust, or merge multiple Eurostat datasets into one record, and
it does not deliver commercial-barred geographies. It gives you faithful, licence-clean, analysis-ready
observation records — one row per published cell — with an auditable provenance trail.

# Actor input Schema

## `sinceTimePeriod` (type: `string`):

Return observations from this year onward (this is an annual cube; latest published year is 2020). Use a year (2015). Earlier start = more records.

## `maxRecords` (type: `integer`):

Maximum records delivered and billed. You are billed only for records actually delivered. Raise it to pull the full set.

## `geo` (type: `string`):

Eurostat geo code to pull (e.g. DE, FR, IT, ES). Required: this cube is too large to return in one request, so it is retrieved one territory at a time.

## Actor input object example

```json
{
  "sinceTimePeriod": "2015",
  "maxRecords": 500,
  "geo": "DE"
}
```

# Actor output Schema

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

The delivered EU business demography record.

# 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 = {
    "sinceTimePeriod": "2015",
    "maxRecords": 500,
    "geo": "DE"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/eu-business-demography-records").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 = {
    "sinceTimePeriod": "2015",
    "maxRecords": 500,
    "geo": "DE",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/eu-business-demography-records").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 '{
  "sinceTimePeriod": "2015",
  "maxRecords": 500,
  "geo": "DE"
}' |
apify call nexgensignal/eu-business-demography-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/eu-business-demography-records"
        }
    }
}

```

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/6urCEIH4Nx3XFi7Qq/builds/k4NTOjIMz2N1uiBXO/openapi.json