# Norwegian Company Lookup - Official Registry Data (Brønnøysund) (`fabriken2026/norwegian-company-lookup`) Actor

Look up Norwegian companies by organisation number: status incl. bankruptcy, legal form, NACE code, key financials. Official Brønnøysund data - never scraped.

- **URL**: https://apify.com/fabriken2026/norwegian-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

## Norwegian Company Lookup - Official Registry Data (Brønnøysund)

**Verified official source - never hallucinated.** This Actor answers
Norwegian company questions with registry data fetched from
**Brønnøysundregistrene** (the Brønnøysund Register Centre) 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 hallucinate Norwegian company facts just as happily
as any others: made-up organisation numbers, wrong legal status, and no
knowledge of last month'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
**Brønnøysundregistrene** - the Norwegian company register - via its
official open API (the Central Coordinating Register,
"Enhetsregisteret").

- **No AI in the loop.** Pure, predictable data lookup. Same input,
  same output, every time.
- **No scraping.** Official open API only - stable fields, no broken
  selectors, no terms-of-service grey zones.
- **Fresh at the source.** Registry data at lookup time, not
  training-data time.
- **Live from day one.** The Norwegian register requires no API key
  at all.
- **GDPR-safe by design** (see below).

### Features

- **Look up any Norwegian limited company by organisation number**
  (organisasjonsnummer), with or without spaces, up to 50 per run.
  The VAT format `NO 923 609 016 MVA` is also accepted.
- **Check if a Norwegian company is active** - current registry
  status, including bankruptcy (konkurs) and deregistered (slettet)
  states, each with the registry's own status date.
- **Get the NACE industry code of a Norwegian company** together with
  its plain-text industry description.
- **Verify a Norwegian organisation number** - the official modulus-11
  checksum is validated before any lookup, so typos never reach the
  API and are never charged.
- **Find the registered office and registration date** of any Norwegian
  limited company (aksjeselskap/allmennaksjeselskap).
- **Optional key financials from the latest filed annual report**
  (open Regnskapsregisteret data): fiscal year, currency, revenue,
  operating result, net result, equity and total assets - included at
  no extra event charge.
- **Company name search** - find an organisation number when you only
  know the name, restricted to limited companies only.

### Use cases

- **KYB / know-your-business checks:** verify that a Norwegian
  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 Norwegian company facts.
- **Nordic supply-chain vetting:** Nordic groups usually have entities
  in several countries - combine this Actor with its Swedish and
  Finnish siblings to screen the whole chain in one workflow.
- **Quick financial screening:** pull headline revenue and net result
  from the latest annual report without opening a PDF.
- **CRM enrichment and data cleaning:** batch-verify organisation
  numbers and refresh status, industry and registered office for
  existing records.
- **Compliance workflows:** document that a fact came from the
  official register, with source and retrieval date on every row.

### Input

```json
{
    "organisationNumbers": ["923 609 016", "883409442"],
    "includeFinancials": true
}
````

Up to 50 numbers per run, with or without spaces. Numbers are
validated with the official modulus-11 check before any lookup -
typos never reach the API.

### Output (dataset items)

```json
{
    "input": "923 609 016",
    "ok": true,
    "orgNumber": "923 609 016",
    "name": "EQUINOR ASA",
    "status": "Aktivt",
    "legalForm": "Allmennaksjeselskap",
    "legalFormCode": "ASA",
    "naceCode": "06.100",
    "naceText": "Utvinning av råolje",
    "registeredOffice": "STAVANGER",
    "registrationDate": "1995-03-12",
    "financials": {
        "fiscalYear": "2024-01-01 - 2024-12-31",
        "currency": "USD",
        "revenue": 72543000000.0,
        "netResult": 8141000000.0,
        "equity": 41090000000.0
    },
    "source": "Brønnøysundregistrene, Enhetsregisteret (data.brreg.no), NLOD",
    "sourceDate": "2026-07-11"
}
```

Invalid numbers, sole proprietorships 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 (financials included) |

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

### FAQ

**Is there a free API for Norwegian company data?**
Brønnøysundregistrene's open API is free at the source, but you still
need input validation, checksum logic, status decoding 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 Norwegian 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 deregistration, each with the registry's own date.

**Does it work with sole proprietorships (enkeltpersonforetak)?**
No, by design. A sole proprietorship's registered name is usually the
owner's personal name, which is personal data under GDPR. Such entities
are always rejected with a clear explanation, and you are not charged.

**What do the financials contain?**
Headline figures from the latest annual report filed in the open
Regnskapsregisteret: fiscal year, currency (note: can be USD for some
groups), revenue, operating result, net result, equity and total
assets. No figures are guessed - if no annual report is on file, the
field is simply absent.

**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
Brønnøysundregistrene 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 proprietorships (enkeltpersonforetak) are always rejected -
  their registered name is usually the owner's personal name (personal
  data under GDPR).
- Board members, managing directors (daglig leder) and any other
  natural persons are **never** returned. The output is a strict
  allowlist of company-level fields.
- Only limited companies (AS/ASA) 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. No API key or login is
needed anywhere in the chain.

### Data source & license

Data comes from **Brønnøysundregistrene** (the Brønnøysund Register
Centre): the Central Coordinating Register for Legal Entities
(Enhetsregisteret) and the open part of the Register of Company
Accounts (Regnskapsregisteret). Contains data under the Norwegian
licence for Open Government data (NLOD) distributed by
Brønnøysundregistrene. Licence: <https://data.norge.no/nlod/> · Source:
<https://data.brreg.no>. This Actor is independent and not affiliated
with, approved by or endorsed by Brønnøysundregistrene. Registry data
may contain errors or lag; always verify critical facts directly at
brreg.no 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 the NLOD licence (including misleading
  presentation of the data or implying endorsement).

### 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 **Nordic Data Tools** family: Swedish company lookup,
company financials, new company registrations, procurement search,
official statistics, Finnish company lookup and EU contract award
lookup - all built on official Nordic and EU data sources.

#### Changelog

- **0.1** - initial release: status (incl. bankruptcy, deregistration),
  legal form, NACE industry code, registered office, registration date
  for Norwegian limited companies (AS/ASA), optional key financials
  from the latest annual report. Pay-per-event pricing.

# Actor input Schema

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

Norwegian organisation numbers (9 digits), with or without spaces, e.g. <code>923 609 016</code>. The VAT format <code>NO 923 609 016 MVA</code> is also accepted. Max 50 per run. Only limited companies (AS/ASA) are returned; sole proprietorships (enkeltpersonforetak) are always rejected for GDPR reasons.

## `includeFinancials` (type: `boolean`):

Also fetch key figures from the company's latest filed annual report (Regnskapsregisteret): revenue, operating result, net result, equity, total assets, currency and fiscal year. Included in the same per-lookup price.

## Actor input object example

```json
{
  "organisationNumbers": [
    "923 609 016",
    "883409442"
  ],
  "includeFinancials": 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 = {
    "organisationNumbers": [
        "923 609 016",
        "883409442"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabriken2026/norwegian-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": [
        "923 609 016",
        "883409442",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fabriken2026/norwegian-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": [
    "923 609 016",
    "883409442"
  ]
}' |
apify call fabriken2026/norwegian-company-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Norwegian Company Lookup - Official Registry Data (Brønnøysund)",
        "description": "Look up Norwegian companies by organisation number: status incl. bankruptcy, legal form, NACE code, key financials. Official Brønnøysund data - never scraped.",
        "version": "0.1",
        "x-build-id": "CjQhcCfJ7S8aaOQ1P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fabriken2026~norwegian-company-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fabriken2026-norwegian-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~norwegian-company-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fabriken2026-norwegian-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~norwegian-company-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fabriken2026-norwegian-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": "Norwegian organisation numbers (9 digits), with or without spaces, e.g. <code>923 609 016</code>. The VAT format <code>NO 923 609 016 MVA</code> is also accepted. Max 50 per run. Only limited companies (AS/ASA) are returned; sole proprietorships (enkeltpersonforetak) are always rejected for GDPR reasons.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeFinancials": {
                        "title": "Include key financials",
                        "type": "boolean",
                        "description": "Also fetch key figures from the company's latest filed annual report (Regnskapsregisteret): revenue, operating result, net result, equity, total assets, currency and fiscal year. Included in the same per-lookup price.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
