# Swedish New Company Registrations (Bolagsverket) (`fabriken2026/swedish-company-registrations`) Actor

New Swedish companies by date range: org number, name, industry (SNI) and event type. Fresh B2B leads from Bolagsverket's official registry - GDPR-safe.

- **URL**: https://apify.com/fabriken2026/swedish-company-registrations.md
- **Developed by:** [David](https://apify.com/fabriken2026) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 registration 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Swedish New Company Registrations (Bolagsverket)

**Verified official source - never hallucinated.** Every row this Actor
returns comes from **Bolagsverket's and SCB's** official registry files -
not from a scraped directory, not from a resold lead database, not from
an AI model's imagination.

### Why this Actor?

Every week, hundreds of new Swedish companies are registered - fresh
leads for banks, insurers, accountants, SaaS vendors and anyone selling
to businesses. LLMs know nothing about a company registered last week,
and commercial lead databases charge heavily for what is, at the source,
free official data. This Actor lists register events straight from the
official datasets, filtered exactly the way a sales team needs them.

### Features

- **List newly registered Swedish companies by date range** - up to 92
  days per run, day-level precision, straight from the official registry
  files.
- **Find new companies in a specific industry** - filter by SNI code
  prefix (e.g. `62` = IT), 2 to 5 digits.
- **Find new companies in a specific county** - optional 2-digit county
  code filter (01 Stockholm - 25 Norrbotten).
- **Track deregistered Swedish companies** too - event type
  `nyregistrerade` (registered), `avregistrerade` (deregistered) or both.
- **Get org number, name, date and event type per row** - ready for CRM
  import, deduplication by organisation number included for free.
- **Official Bolagsverket/SCB open data** - no scraping, no AI in the
  loop. Same query, same behaviour, every time.
- **GDPR-safe B2B lead generation** - limited companies only; sole
  traders are always excluded by design.

### Use cases

- **Weekly lead lists for B2B sales:** schedule one run per industry you
  sell to and push new companies to webhook, e-mail or your CRM (a
  typical weekly run of 50 companies costs $0.20).
- **Banks, insurers and accountants:** reach newly started aktiebolag in
  your region during their first weeks - when they are choosing
  providers.
- **Churn and risk monitoring:** watch for deregistrations among your
  customers or suppliers.
- **Market intelligence:** where and in which industries is company
  formation growing? Grounded in registry events, not survey estimates.
- **AI sales agents:** give an agent a deterministic source of fresh
  Swedish leads it can filter, rank and write outreach for.

### Input

```json
{
    "dateFrom": "2026-07-01",
    "dateTo": "2026-07-07",
    "eventType": "nyregistrerade",
    "sniPrefix": "62",
    "countyCode": "01",
    "maxRows": 500
}
````

`dateFrom`/`dateTo` are required (`YYYY-MM-DD`, max 92 days).
`eventType`: `nyregistrerade` (registered), `avregistrerade`
(deregistered) or `alla` (both, default). `sniPrefix` is an optional
2-5 digit industry filter, `countyCode` an optional 2-digit county
filter.

### Output (dataset items)

```json
{
    "orgNumber": "556123-0003",
    "name": "Nystartade Molntjänster AB",
    "legalForm": "Limited company (aktiebolag)",
    "date": "2026-07-06",
    "eventType": "REGISTERED",
    "sniCode": "62010",
    "countyCode": "01",
    "source": "Bolagsverket/SCB - Swedish official registry open data",
    "dataMode": "LIVE"
}
```

Verify any business-critical fact directly with Bolagsverket before
acting on it.

### Pricing (pay-per-event)

| Event | Price | When |
|---|---|---|
| `registration-row` | $0.004 | Per result row written to the dataset |

Invalid searches and empty results are free. A typical weekly lead run
(50 new IT companies) costs $0.20; 1,000 rows cost $4. Compare that with
commercial lead databases charging thousands of SEK per month for the
same public registry events. No subscription, no minimum.

**Tip:** schedule a weekly run per industry you sell to, delivered to
webhook, e-mail or your CRM.

### FAQ

**How do I get a list of newly registered companies in Sweden?**
Give this Actor a date range (and optionally an industry and county) and
it returns every matching registration event from the official registry
files as clean JSON rows - $0.004 per row.

**How fresh is the data?**
The official source files are updated **weekly** - a company registered
yesterday may appear only after the next file drop. That is a property
of the source, stated honestly; no scraper gets you closer to the
register than the register's own files.

**Are sole traders (enskild firma) included?**
No, by design. A sole trader's registration number is the owner's
personal identity number - personal data under GDPR. Only limited
companies (aktiebolag) are returned, and the number of filtered rows is
reported openly in every run.

**Can I use the list for direct marketing?**
The data itself is public registry data about legal entities. Complying
with marketing law and GDPR in your own outreach is your responsibility -
see Terms of use.

**Can my AI agent use this?**
Yes - via the Apify API or MCP. Flat JSON rows keyed by organisation
number, ready for an agent to filter, enrich (e.g. with the Swedish
Company Lookup Actor from the same family) and act on.

**Why not buy leads from a commercial database instead?**
You can - they resell the same registry events with markup and opaque
filtering. Here you get the primary source, transparent filters and a
price per row instead of a subscription.

### GDPR & privacy by design

- Only limited companies (aktiebolag) are returned. Sole traders are
  always excluded - their registration number IS the owner's personal
  identity number.
- Board members, contact persons or any personal data are **never
  requested from the source and never returned**.
- The GDPR filter runs in two layers (adapter + core validation), and
  the count of filtered rows is reported in every run.

### Permissions & security

This Actor runs with Apify's **limited permissions** model: it reads its
own input, writes to its own default dataset and fetches the official
open data files over HTTPS - nothing else. No API key is needed anywhere,
and it requests no access to your other Actors, storages or account data.

### Data source & license

Data comes from **Bolagsverket (the Swedish Companies Registration
Office) and SCB (Statistics Sweden)** via their free "high-value
datasets" (EU Open Data Directive) - a license regime that permits reuse,
including commercial reuse, fee-free since February 2025, no agreement
required. Source: Bolagsverket and SCB, high-value datasets (fee-free
under EU Regulation 2023/138). This Actor is independent and not
affiliated with or endorsed by Bolagsverket or SCB.

### Terms of use

- **Business use only.** This Actor is intended exclusively for use in
  the course of business (B2B). By using it you confirm you are acting
  as a business, not a consumer.
- **As is.** The service and all data are provided "as is", without
  warranties of any kind - no guarantee of accuracy, completeness,
  timeliness or availability.
- **Liability cap.** Total aggregate liability for all claims in any
  12-month period is limited to the amount you paid for the service in
  that period. No liability for indirect or consequential damages, lost
  profits, lost business opportunities or lost data. Nothing in these
  terms limits liability that cannot lawfully be limited.
- **Fair use.** No bulk re-selling of raw data, no circumventing rate
  limits. If you use the lists for direct marketing, complying with
  marketing law and GDPR in your own processing is your responsibility.

### Versioning & support

Versions are locked - the Actor never silently changes behaviour under
you. Changes are released as new versions with a changelog entry.

Part of the **Swedish Data Tools** family: company lookup, company
financials, new company registrations, public procurement search and
official statistics - all built on official Swedish and EU data sources.

#### Changelog

- **0.1** - initial release: date-range listing of registered/
  deregistered limited companies with SNI and county filters,
  pay-per-row pricing. (Pre-release: sample data mode.)

# Actor input Schema

## `dateFrom` (type: `string`):

Start of the date range, <code>YYYY-MM-DD</code>. Max 92 days per run.

## `dateTo` (type: `string`):

End of the date range, <code>YYYY-MM-DD</code>.

## `eventType` (type: `string`):

Which register events to include.

## `sniPrefix` (type: `string`):

Optional industry filter: 2-5 digits, e.g. <code>62</code> = IT services, <code>56</code> = restaurants. Shorter code matches the whole sector.

## `countyCode` (type: `string`):

Optional county filter: 2 digits, <code>01</code> Stockholm to <code>25</code> Norrbotten.

## `maxRows` (type: `integer`):

How many rows to return (1-1000).

## `rebuildIndex` (type: `boolean`):

Internal maintenance flag. Rebuilds the preprocessed registry index and stores it. Handled automatically by a weekly schedule - leave off for normal searches.

## Actor input object example

```json
{
  "dateFrom": "2026-07-01",
  "dateTo": "2026-07-07",
  "eventType": "alla",
  "maxRows": 500,
  "rebuildIndex": false
}
```

# 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 = {
    "dateFrom": "2026-07-01",
    "dateTo": "2026-07-07"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabriken2026/swedish-company-registrations").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 = {
    "dateFrom": "2026-07-01",
    "dateTo": "2026-07-07",
}

# Run the Actor and wait for it to finish
run = client.actor("fabriken2026/swedish-company-registrations").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "dateFrom": "2026-07-01",
  "dateTo": "2026-07-07"
}' |
apify call fabriken2026/swedish-company-registrations --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fabriken2026/swedish-company-registrations",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swedish New Company Registrations (Bolagsverket)",
        "description": "New Swedish companies by date range: org number, name, industry (SNI) and event type. Fresh B2B leads from Bolagsverket's official registry - GDPR-safe.",
        "version": "0.1",
        "x-build-id": "A1eHS5kTfSd00eGe9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fabriken2026~swedish-company-registrations/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fabriken2026-swedish-company-registrations",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fabriken2026~swedish-company-registrations/runs": {
            "post": {
                "operationId": "runs-sync-fabriken2026-swedish-company-registrations",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fabriken2026~swedish-company-registrations/run-sync": {
            "post": {
                "operationId": "run-sync-fabriken2026-swedish-company-registrations",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "dateFrom",
                    "dateTo"
                ],
                "properties": {
                    "dateFrom": {
                        "title": "From date",
                        "type": "string",
                        "description": "Start of the date range, <code>YYYY-MM-DD</code>. Max 92 days per run."
                    },
                    "dateTo": {
                        "title": "To date",
                        "type": "string",
                        "description": "End of the date range, <code>YYYY-MM-DD</code>."
                    },
                    "eventType": {
                        "title": "Event type",
                        "enum": [
                            "nyregistrerade",
                            "avregistrerade",
                            "alla"
                        ],
                        "type": "string",
                        "description": "Which register events to include.",
                        "default": "alla"
                    },
                    "sniPrefix": {
                        "title": "Industry (SNI code prefix)",
                        "type": "string",
                        "description": "Optional industry filter: 2-5 digits, e.g. <code>62</code> = IT services, <code>56</code> = restaurants. Shorter code matches the whole sector."
                    },
                    "countyCode": {
                        "title": "County code",
                        "type": "string",
                        "description": "Optional county filter: 2 digits, <code>01</code> Stockholm to <code>25</code> Norrbotten."
                    },
                    "maxRows": {
                        "title": "Max rows",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many rows to return (1-1000).",
                        "default": 500
                    },
                    "rebuildIndex": {
                        "title": "Rebuild index (maintenance)",
                        "type": "boolean",
                        "description": "Internal maintenance flag. Rebuilds the preprocessed registry index and stores it. Handled automatically by a weekly schedule - leave off for normal searches.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
