# Swedish Company Lookup (Bolagsverket) (`fabriken2026/swedish-company-lookup`) Actor

Look up any Swedish company by org number: status, legal form, SNI industry code, registered office. Official Bolagsverket registry data - never scraped.

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

## Pricing

$6.00 / 1,000 successful company lookups

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 Company Lookup (Bolagsverket)

**Verified official source - never hallucinated.** This Actor answers
company questions with registry data fetched from **Bolagsverket** (the
Swedish Companies Registration Office) at lookup time - not with an AI
model's guess and not with a scraped snapshot of somebody's website.

### Why this Actor?

LLMs and AI agents routinely hallucinate Swedish company facts: made-up
organisation numbers, wrong legal status, and no knowledge of yesterday's
bankruptcies. Generic AI web search is not much better - it summarises
whatever page ranks first, which may be stale, unofficial or plain wrong.
This Actor gives your agent (or workflow) a deterministic, verifiable
lookup against the official Swedish company register, via Bolagsverket's
open API for high-value datasets.

### Features

- **Look up any Swedish company by org number** (organisationsnummer),
  with or without hyphen, up to 50 per run.
- **Check if a Swedish company is active** - current registry status,
  including bankruptcy and liquidation states.
- **Get the SNI industry code of a Swedish company** together with its
  plain-text industry description.
- **Verify a Swedish organisation number** - built-in checksum (Luhn)
  validation rejects invalid numbers before any lookup is charged.
- **Find the registered office and registration date** of any Swedish
  limited company (aktiebolag).
- **Official Bolagsverket registry data** - no scraping, no third-party
  databases, no AI in the loop. Same input, same output, every time.
- **GDPR-safe company data API** - legal entities only, personal data is
  rejected at the gate (see below).

### Use cases

- **KYB / know-your-business checks:** verify that a counterparty exists,
  is active and is what it claims to be, before onboarding.
- **AI agents that must not hallucinate:** give Claude, ChatGPT or any
  MCP/tool-calling agent a grounded source for Swedish company facts.
- **CRM enrichment and data cleaning:** batch-verify org numbers and
  refresh status, industry and registered office for existing records.
- **Due diligence and supplier vetting:** a deterministic first screen
  before you pay for a full credit report.
- **Compliance workflows:** document that a fact came from the official
  register, with source and retrieval date on every row.

### Input

```json
{
    "organisationNumbers": ["556999-9997", "559999-9991", "556999-9989"]
}
````

Up to 50 numbers per run, with or without hyphen.

### Output (dataset items)

```json
{
    "input": "556999-9997",
    "ok": true,
    "orgNumber": "556999-9997",
    "name": "Testbolaget Exempel AB",
    "status": "Aktivt",
    "legalForm": "Aktiebolag",
    "sniCode": "62010",
    "sniText": "Dataprogrammering",
    "registeredOffice": "Stockholm",
    "registrationDate": "2015-03-12",
    "source": "Bolagsverket, API för värdefulla datamängder",
    "sourceDate": "2026-07-10",
    "dataMode": "LIVE"
}
```

Invalid numbers and companies that are not found come back as items with
`ok: false` and an explanation - and are **never charged**. The run itself
still succeeds, so your pipeline never breaks on a bad input row.

### Pricing (pay-per-event)

| Event | Price | When |
|---|---|---|
| `company-lookup` | $0.006 | Per successful lookup only |

That is ~$6 per 1,000 companies. Failed validations and not-found results
are free. No subscription, no minimum, no rental fee.

### FAQ

**Is there a free API for Swedish company data?**
Bolagsverket's high-value dataset API is free at the source, but you need
a registered client, OAuth handling, rate-limit discipline and GDPR
filtering. This Actor packages all of that into one call at $0.006 per
company - you pay for the plumbing, not the data.

**How do I check if a Swedish company is bankrupt?**
Run its organisation number through this Actor and read the `status`
field, which reflects the register at lookup time - including bankruptcy
and liquidation states.

**Does it work with sole traders (enskild firma)?**
No, by design. A sole trader's organisation number is the owner's
personal identity number, which is personal data under GDPR. Such numbers
are always rejected with a clear explanation, and you are not charged.

**Can my AI agent use this?**
Yes - that is the primary design goal. Call it from any agent framework
via the Apify API or via MCP. The output is small, flat JSON that fits
comfortably in an agent's context window.

**How fresh is the data?**
Every lookup goes to the registry API at run time. You get what
Bolagsverket has right now, not what a model memorised during training.

**Why should I trust these results over an AI web search?**
Because nothing here is generated. Every field is copied from the
official register and every row carries `source` and `sourceDate`, so the
answer is auditable.

### GDPR & privacy by design

This Actor handles **legal entities only**:

- Sole traders are always rejected - their organisation number is the
  owner's personal identity number (personal data under GDPR).
- Board members, directors and any other natural persons are **never**
  returned. The output is a strict allowlist of company-level fields.
- Only limited companies (aktiebolag) are supported in v1.

### Permissions & security

This Actor runs with Apify's **limited permissions** model: it reads its
own input, writes to its own default dataset and calls the official
registry API over HTTPS - nothing else. It requests no access to your
other Actors, storages or account data.

### Data source & license

Data comes from **Bolagsverket** (Swedish Companies Registration Office),
API for high-value datasets. Free of charge under EU Implementing
Regulation 2023/138 on high-value datasets - the license permits reuse,
including commercial reuse. This Actor is independent and not affiliated
with or endorsed by Bolagsverket. Registry data may contain errors or
lag; always verify critical facts directly at bolagsverket.se before
acting on them.

### 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 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, no use that violates Bolagsverket's terms.

### 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: status, legal form, SNI, registered office,
  registration date for Swedish limited companies. Pay-per-event pricing.

# Actor input Schema

## `organisationNumbers` (type: `array`):

Swedish organisation numbers of limited companies (aktiebolag), with or without hyphen, e.g. <code>556999-9997</code>. Max 50 per run. Sole traders are always rejected: their organisation number is the owner's personal identity number (personal data under GDPR).

## Actor input object example

```json
{
  "organisationNumbers": [
    "556999-9997",
    "559999-9991",
    "556999-9989"
  ]
}
```

# 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 = {
    "organisationNumbers": [
        "556999-9997",
        "559999-9991",
        "556999-9989"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabriken2026/swedish-company-lookup").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 = { "organisationNumbers": [
        "556999-9997",
        "559999-9991",
        "556999-9989",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fabriken2026/swedish-company-lookup").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 '{
  "organisationNumbers": [
    "556999-9997",
    "559999-9991",
    "556999-9989"
  ]
}' |
apify call fabriken2026/swedish-company-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swedish Company Lookup (Bolagsverket)",
        "description": "Look up any Swedish company by org number: status, legal form, SNI industry code, registered office. Official Bolagsverket registry data - never scraped.",
        "version": "0.1",
        "x-build-id": "VKbx2midyvnUscB6E"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fabriken2026~swedish-company-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fabriken2026-swedish-company-lookup",
                "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-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fabriken2026-swedish-company-lookup",
                "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-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fabriken2026-swedish-company-lookup",
                "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": [
                    "organisationNumbers"
                ],
                "properties": {
                    "organisationNumbers": {
                        "title": "Organisation numbers",
                        "type": "array",
                        "description": "Swedish organisation numbers of limited companies (aktiebolag), with or without hyphen, e.g. <code>556999-9997</code>. Max 50 per run. Sole traders are always rejected: their organisation number is the owner's personal identity number (personal data under GDPR).",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```