Platform mentioned for supporting the development of the MCP server through donations
Source code repository hosting and issue tracking for the MCP server project
Sponsorship platform for supporting ongoing development and maintenance of the MCP server
Provides comprehensive access to Norway's official business registry (Brønnøysundregistrene) for querying company information, board members, subsidiaries, and voluntary organizations
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Norwegian Business Registry MCP Server find detailed information about Equinor ASA"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server providing comprehensive access to the Norwegian Business Registry (Brønnøysundregistrene) API. Query Norwegian companies, subsidiaries, board members, organizational data, and voluntary organizations through AI assistants like Claude.
Company Search: Find Norwegian businesses by name, location, industry, employee count, and registration status
Detailed Company Information: Access comprehensive data including financial status, contact information, and corporate structure
Board and Management Data: Retrieve current board members, management roles, and corporate governance information
Subsidiary Relationships: Explore parent-subsidiary relationships and corporate hierarchies
Reference Data: Access organizational forms, municipalities, industry classifications, and regulatory information
Voluntary Organizations: Query Norway's registry of non-profit organizations with ICNPO classifications
Real-time Updates: Track changes in company registrations and corporate structures
Related MCP server: Brreg MCP Server
npm install -g brreg-mcp-servergit clone https://github.com/reidar80/brreg-mcp-server.git
cd brreg-mcp-server
npm install
npm run buildAdd to your claude_desktop_config.json:
Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
{
"mcpServers": {
"brreg-api": {
"command": "brreg-mcp",
"args": []
}
}
}After configuration, restart Claude Desktop. The Norwegian Business Registry tools will be available for queries.
"Find Norwegian oil and gas companies with more than 1000 employees"
"Get detailed information about Equinor ASA"
"Show me all board members of DNB Bank"
"List subsidiaries of Telenor Group"
"Find sports organizations in Oslo registered as voluntary organizations"
"What are the different organizational forms available in Norway?"
search_entities - Search Norwegian companies with comprehensive filters
get_entity - Retrieve detailed company information by organization number
get_entity_roles - Get board members, management, and auditor information
search_sub_entities - Find subsidiaries, branches, and departments
get_sub_entity - Get detailed information about specific sub-entities
get_organizational_forms - Norwegian business entity types and descriptions
get_organizational_form - Specific organizational form details
get_municipalities - Norwegian municipalities and geographic codes
get_municipality - Specific municipality information
search_voluntary_organizations - Search non-profit organizations
get_voluntary_organization - Detailed voluntary organization information
get_icnpo_categories - International Classification of Non-Profit Organisation categories
get_entity_updates - Track changes in company registrations
get_sub_entity_updates - Monitor subsidiary changes
get_role_updates - Follow board and management changes
Due Diligence: Research companies, their leadership, and corporate structure
Market Research: Analyze industry sectors, company sizes, and geographic distribution
Compliance Monitoring: Track regulatory changes and corporate governance updates
Business Intelligence: Understand Norwegian market dynamics and competitive landscapes
Academic Research: Access comprehensive data on Norwegian business ecosystem
Legal Research: Verify corporate information and regulatory status
This MCP server uses the official Norwegian Business Registry API provided by Brønnøysundregistrene. The registry contains:
Over 1 million registered entities
Complete corporate hierarchies and ownership structures
Real-time updates on business registrations and changes
Comprehensive board and management information
Full regulatory and compliance status data
All data is public information made available under the Norwegian License for Open Government Data (NLOD).
Node.js 18.0.0 or higher
NPM 8.0.0 or higher
Internet connection for API access
Contributions are welcome! Please:
Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Make your changes
Add tests for new functionality
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request
Report bugs or request features via GitHub Issues
For questions about the Norwegian Business Registry data, consult Brønnøysundregistrene documentation
This project is licensed under the MIT License - see the LICENSE file for details.
The Norwegian Business Registry data is provided under the Norwegian License for Open Government Data (NLOD) by Brønnøysundregistrene.
Reidar J. Boldevin
Email: reidar.boldevin@outlook.com
GitHub: @reidar80
If this MCP server helps your business or research, consider supporting its development:
Your support helps maintain and improve this tool for the Norwegian business community.
This MCP server provides a modern interface to data from Brønnøysundregistrene (The Brønnøysund Register Centre), Norway's official business registry. Special thanks to Brønnøysundregistrene for maintaining comprehensive open data APIs that make projects like this possible.
Get detailed information about a specific Norwegian business entity
| Name | Required | Description | Default |
|---|---|---|---|
| organisasjonsnummer | Yes | 9-digit organization number |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), which is clear, but lacks details on permissions, rate limits, error handling, or response format. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the key information ('Get detailed information about a specific Norwegian business entity'). There is zero waste, making it highly concise and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is adequate but incomplete. It clarifies the purpose but misses usage guidelines and behavioral details, making it minimally viable for an agent to attempt use, though with clear gaps in contextual understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'organisasjonsnummer' documented as a '9-digit organization number'. The description adds no additional parameter semantics beyond this, so it meets the baseline of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about a specific Norwegian business entity'), making the purpose immediately understandable. However, it doesn't differentiate from siblings like 'get_entity_roles' or 'search_entities' that might also retrieve entity information, so it falls short of a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'search_entities' or 'get_entity_roles'. It implies usage for a specific entity but offers no exclusions or context about prerequisites, leaving the agent to guess based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all roles for a specific entity
| Name | Required | Description | Default |
|---|---|---|---|
| organisasjonsnummer | Yes | 9-digit organization number |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'Get all roles' but doesn't disclose behavioral traits like whether this is a read-only operation, if it requires authentication, rate limits, or what format the roles are returned in. This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a simple input schema, the description is incomplete. It doesn't explain what 'roles' entail, how they're returned, or any prerequisites, making it inadequate for effective tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with one parameter 'organisasjonsnummer' documented as a '9-digit organization number'. The description adds no additional meaning beyond this, so it meets the baseline of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get all roles for a specific entity' clearly states the action (get) and target (roles for an entity), but it's vague about what 'entity' refers to and doesn't differentiate from siblings like 'get_entity' or 'get_role_updates'. It avoids tautology but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. With siblings like 'get_entity' (likely retrieves entity details) and 'get_role_updates' (likely retrieves role changes), the description offers no context for choosing between them, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get updates on entities for maintaining a local copy of the registry
| Name | Required | Description | Default |
|---|---|---|---|
| dato | No | Show updates from this timestamp (ISO-8601) | |
| oppdateringsid | No | Show updates from this update ID | |
| organisasjonsnummer | No | Filter by organization numbers | |
| page | No | Page number | |
| size | No | Page size (default 20, max 10000) | |
| sort | No | Sort by ID (ASC/DESC) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions 'updates' and 'maintaining a local copy', implying incremental/changed data retrieval, but doesn't disclose pagination behavior (beyond schema), rate limits, authentication needs, error conditions, or what constitutes an 'update'. The schema covers parameters but not operational behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('Get updates on entities') and purpose ('for maintaining a local copy of the registry'). There is no wasted verbiage or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'updates' include (e.g., created/modified/deleted entities), return format, error handling, or how it interacts with siblings. The purpose is clear but operational context is lacking.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds no additional parameter semantics beyond implying temporal filtering ('updates') and registry context. It doesn't explain relationships between parameters like dato and oppdateringsid, or provide usage examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get updates' and the resource 'entities', and specifies the purpose 'for maintaining a local copy of the registry'. It distinguishes from siblings like get_entity (which likely gets single entities) and get_entity_roles (which gets roles), but doesn't explicitly differentiate from get_sub_entity_updates or get_role_updates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like get_entity, get_sub_entity_updates, or search_entities. It mentions the purpose of maintaining a local registry copy, but doesn't specify prerequisites, timing, or exclusion criteria relative to other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get ICNPO (International Classification of Non-Profit Organisation) categories
| Name | Required | Description | Default |
|---|---|---|---|
| spraak | No | Language for descriptions (e.g., 'NOB') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states it 'gets' categories, implying a read-only operation, but doesn't disclose behavioral traits like rate limits, authentication needs, or response format. This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., list structure, fields) or behavioral aspects, leaving gaps for a tool that likely outputs data.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents the single parameter 'spraak' with its description. The description adds no additional meaning beyond what the schema provides, such as example values or constraints, resulting in a baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('ICNPO categories'), making the purpose understandable. It doesn't distinguish from siblings like 'get_organizational_form' or 'get_municipalities', which also retrieve categories/lists, so it lacks specific differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage based on the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all Norwegian municipalities
| Name | Required | Description | Default |
|---|---|---|---|
| sort | No | Sort order | |
| size | No | Page size | |
| page | No | Page number |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it 'gets' data, implying a read-only operation, but lacks details on permissions, rate limits, pagination behavior (implied by parameters but not explained), or response format. This is inadequate for a tool with parameters and no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has parameters (sort, size, page) and no output schema, the description is incomplete. It doesn't address how the tool behaves with pagination, what data is returned, or error conditions. For a list-retrieval tool with parameters, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, providing basic parameter definitions. The description adds no additional meaning beyond implying retrieval of municipalities, but it doesn't explain how parameters like 'sort' or 'page' affect the results. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('all Norwegian municipalities'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_municipality' (singular) or 'search_entities' that might overlap in functionality, missing explicit distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_municipality' (likely for a single municipality) and 'search_entities' (potentially broader searches), there's no indication of context, exclusions, or prerequisites for selecting this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get information about a specific Norwegian municipality
| Name | Required | Description | Default |
|---|---|---|---|
| kommunenummer | Yes | 4-digit municipality number (e.g., '0301' for Oslo) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a read operation ('Get information'), but doesn't mention any behavioral traits like error handling (e.g., what happens with invalid kommunenummer), response format, data freshness, or rate limits. The description is minimal and lacks operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that efficiently communicates the core purpose. It's appropriately sized for a simple lookup tool and wastes no words. The structure is straightforward with no unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter lookup tool with good schema coverage but no output schema, the description is minimally adequate. It states what the tool does but lacks context about the information returned, error conditions, or how it differs from sibling tools. Given the complexity is low, it's passable but could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage with a clear parameter description, so the baseline is 3. The tool description doesn't add any parameter semantics beyond what's already in the schema - it mentions 'specific Norwegian municipality' which aligns with the parameter but provides no additional context about parameter usage or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get information') and resource ('specific Norwegian municipality'), making the purpose immediately understandable. It distinguishes from sibling 'get_municipalities' (plural) by specifying retrieval of a single municipality, though it doesn't explicitly contrast with other entity-related tools like 'get_entity' or 'search_entities'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_municipalities' (for multiple municipalities), 'get_entity' (for general entities), or 'search_entities' (for filtered searches). It simply states what the tool does without any contextual usage information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get information about a specific organizational form
| Name | Required | Description | Default |
|---|---|---|---|
| organisasjonskode | Yes | Organizational form code (e.g., 'AS', 'ASA') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves information, implying a read-only operation, but does not specify details like error handling, authentication needs, rate limits, or response format, which are critical for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with no wasted words, making it easy to parse and front-loaded with the core action. It efficiently conveys the essential purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read tool with one well-documented parameter and no output schema, the description is minimally adequate but lacks depth. It does not explain what 'information' includes or behavioral traits, leaving gaps that could hinder effective tool selection and use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting the single required parameter 'organisasjonskode' with examples. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for adequate but unenhanced coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('information about a specific organizational form'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'get_organizational_forms' (plural), which might retrieve a list, leaving some ambiguity in scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as 'get_organizational_forms' for multiple forms or other entity-related tools. It lacks context on prerequisites or exclusions, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get all organizational forms used in the Norwegian business registry
| Name | Required | Description | Default |
|---|---|---|---|
| sort | No | Sort order (ASC/DESC) | |
| size | No | Page size | |
| page | No | Page number |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation ('Get all') but doesn't specify details like pagination behavior (implied by parameters but not explained), rate limits, authentication needs, or error handling, leaving significant gaps for a tool with parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and appropriately sized, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (3 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain the return format, pagination behavior, or how parameters interact, which are crucial for effective use. The lack of annotations and output schema increases the need for more descriptive context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, documenting all three parameters (sort, size, page) clearly. The description adds no additional meaning beyond the schema, such as default values or usage examples, so it meets the baseline for adequate but not enhanced parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get all') and resource ('organizational forms used in the Norwegian business registry'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_organizational_form' (singular), which might retrieve a specific form, leaving some ambiguity about scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as 'get_organizational_form' for a single form or 'search_entities' for broader queries. It lacks context on prerequisites, exclusions, or recommended scenarios, offering minimal usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get role updates for entities
| Name | Required | Description | Default |
|---|---|---|---|
| afterTime | No | Get events after this timestamp (ISO-8601) | |
| afterId | No | Get events after this ID | |
| organisasjonsnummer | No | Filter by organization numbers | |
| size | No | Number of events to retrieve (default 100, max 10000) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what the tool does without mentioning permissions, rate limits, pagination, or response format. For a tool with 4 parameters and no output schema, this lack of detail is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'role updates' entail, how results are returned, or any behavioral traits, leaving the agent with insufficient context to use the tool effectively beyond basic parameter input.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema fully documents all parameters. The description adds no additional meaning beyond the schema, such as explaining relationships between parameters (e.g., 'afterTime' vs. 'afterId') or typical use cases. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get role updates for entities' states a purpose with a verb ('Get') and resource ('role updates'), but it's vague about what 'role updates' means and doesn't distinguish it from siblings like 'get_entity_roles' or 'get_entity_updates'. It lacks specificity about the scope or nature of these updates.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_entity_roles' and 'get_entity_updates', there's no indication of how this tool differs in context, such as whether it's for historical changes, real-time updates, or filtered views, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific Norwegian business sub-entity
| Name | Required | Description | Default |
|---|---|---|---|
| organisasjonsnummer | Yes | 9-digit organization number |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states it 'gets detailed information' without specifying what 'detailed' includes, whether it's read-only, requires authentication, has rate limits, or returns structured data. This leaves significant behavioral gaps for a tool with unknown operational characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded with the core action, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations, no output schema, and multiple sibling tools, the description is insufficient. It doesn't explain what 'detailed information' entails, how it differs from similar tools, or any behavioral constraints, leaving the agent with inadequate context to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameter 'organisasjonsnummer' is documented in the schema as a '9-digit organization number'. The description adds no additional parameter semantics beyond implying it identifies a 'specific Norwegian business sub-entity', which aligns with but doesn't extend the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and resource 'detailed information about a specific Norwegian business sub-entity', making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_entity' or 'get_sub_entity_updates', which would require more specific scope clarification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'get_entity', 'search_sub_entities', or 'get_sub_entity_updates'. The description mentions 'specific' but doesn't clarify prerequisites or contextual triggers for choosing this tool over siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get updates on sub-entities for maintaining a local copy of the registry
| Name | Required | Description | Default |
|---|---|---|---|
| dato | No | Show updates from this timestamp (ISO-8601) | |
| oppdateringsid | No | Show updates from this update ID | |
| organisasjonsnummer | No | Filter by organization numbers | |
| page | No | Page number | |
| size | No | Page size (default 20, max 10000) | |
| sort | No | Sort by ID (ASC/DESC) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks behavioral details. It doesn't disclose whether this is a read-only operation, pagination behavior beyond schema hints, rate limits, authentication requirements, or what the updates contain. The phrase 'maintaining a local copy' implies incremental synchronization but isn't specific.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place—no redundancy or fluff. It's appropriately sized for a tool with good schema coverage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 6-parameter tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'updates' consist of, return format, error conditions, or how it fits with sibling tools. The schema covers parameters well, but behavioral and output context is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 6 parameters. The description adds no additional parameter semantics beyond implying temporal filtering ('updates') and registry context. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get updates') and resource ('on sub-entities'), and specifies the purpose ('for maintaining a local copy of the registry'). It distinguishes from siblings like 'get_sub_entity' (which likely retrieves static data) by focusing on updates, but doesn't explicitly differentiate from 'get_entity_updates' or 'get_role_updates'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_entity_updates', 'get_role_updates', or 'search_sub_entities'. It mentions the general purpose but offers no context about prerequisites, typical use cases, or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific voluntary organization
| Name | Required | Description | Default |
|---|---|---|---|
| organisasjonsnummer | Yes | 9-digit organization number | |
| spraak | No | Language for code descriptions (e.g., 'NOB') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states this is a 'Get' operation, implying read-only behavior, but doesn't disclose any behavioral traits such as authentication needs, rate limits, error conditions, or what 'detailed information' includes. For a tool with no annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get detailed information about a specific voluntary organization'). There is no wasted text, and it's appropriately sized for a simple lookup tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'detailed information' entails, potential response formats, or any behavioral aspects. For a tool with 2 parameters and no structured output documentation, more context is needed to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (organisasjonsnummer and spraak) with descriptions. The description adds no additional meaning beyond what the schema provides, such as examples or usage context. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get detailed information') and target resource ('about a specific voluntary organization'), which distinguishes it from siblings like search_voluntary_organizations (which searches) and get_entity (which is more general). However, it doesn't explicitly differentiate from get_entity or other get_* tools beyond specifying 'voluntary organization'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over get_entity (which might handle similar data) or search_voluntary_organizations, nor does it specify prerequisites or exclusions. The context is implied but not articulated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for Norwegian business entities (hovedenheter) with various filters
| Name | Required | Description | Default |
|---|---|---|---|
| navn | No | Entity name (1-180 characters) | |
| navnMetodeForSoek | No | Search method for name parameter | |
| organisasjonsnummer | No | List of organization numbers (9 digits) | |
| overordnetEnhet | No | Parent entity organization number | |
| fraAntallAnsatte | No | Minimum number of employees | |
| tilAntallAnsatte | No | Maximum number of employees | |
| konkurs | No | Whether entity is bankrupt | |
| registrertIMvaregisteret | No | Registered in VAT registry | |
| registrertIForetaksregisteret | No | Registered in business registry | |
| registrertIStiftelsesregisteret | No | Registered in foundation registry | |
| registrertIFrivillighetsregisteret | No | Registered in voluntary organization registry | |
| underTvangsavviklingEllerTvangsopplosning | No | Under forced liquidation | |
| underAvvikling | No | Under liquidation | |
| underKonkursbehandling | No | Under bankruptcy proceedings | |
| organisasjonsform | No | Organizational forms | |
| hjemmeside | No | Website | |
| kommunenummer | No | Municipality numbers | |
| naeringskode | No | Industry codes | |
| size | No | Page size (default 20) | |
| page | No | Page number | |
| sort | No | Sort field and order (e.g., 'navn,ASC') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It doesn't disclose whether this is a read-only operation, if it has rate limits, authentication requirements, pagination behavior (implied by 'size' and 'page' parameters but not explained), or what the output format looks like. The phrase 'Search for' suggests a query operation, but no further details are given.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It could be slightly more structured by explicitly mentioning pagination or result format, but it avoids redundancy and wastes no words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex search tool with 21 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain the search scope, result format, pagination, error conditions, or how to interpret the numerous boolean and array filters. The agent would struggle to use this effectively without trial and error.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 21 parameters. The description adds no parameter-specific information beyond mentioning 'various filters', which is already evident from the schema. This meets the baseline of 3 when schema coverage is high, but doesn't provide additional semantic context like how filters combine or which are most commonly used.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search for') and resource ('Norwegian business entities (hovedenheter)'), specifying the entity type and geographic scope. However, it doesn't explicitly differentiate from sibling tools like 'search_sub_entities' or 'search_voluntary_organizations', which search different entity types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_entity' (for specific entities) or other search tools for sub-entities or voluntary organizations. It mentions 'various filters' but doesn't explain when filtering is appropriate or what distinguishes this search from other retrieval methods.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for Norwegian business sub-entities (underenheter) with various filters
| Name | Required | Description | Default |
|---|---|---|---|
| navn | No | Sub-entity name (1-180 characters) | |
| navnMetodeForSoek | No | Search method for name parameter | |
| organisasjonsnummer | No | List of organization numbers (9 digits) | |
| overordnetEnhet | No | Parent entity organization number | |
| fraAntallAnsatte | No | Minimum number of employees | |
| tilAntallAnsatte | No | Maximum number of employees | |
| registrertIMvaregisteret | No | Registered in VAT registry | |
| fraOppstartsdato | No | Start date from (ISO-8601 yyyy-MM-dd) | |
| tilOppstartsdato | No | Start date to (ISO-8601 yyyy-MM-dd) | |
| fraDatoEierskifte | No | Ownership change date from (ISO-8601 yyyy-MM-dd) | |
| tilDatoEierskifte | No | Ownership change date to (ISO-8601 yyyy-MM-dd) | |
| fraNedleggelsesdato | No | Closure date from (ISO-8601 yyyy-MM-dd) | |
| tilNedleggelsesdato | No | Closure date to (ISO-8601 yyyy-MM-dd) | |
| organisasjonsform | No | Organizational forms | |
| hjemmeside | No | Website | |
| kommunenummer | No | Municipality numbers | |
| naeringskode | No | Industry codes | |
| size | No | Page size (default 20) | |
| page | No | Page number | |
| sort | No | Sort field and order |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions searching with filters but doesn't describe what the tool returns (format, structure), pagination behavior (implied by 'size' and 'page' parameters but not explained), rate limits, authentication requirements, or error conditions. This is inadequate for a search tool with 20 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for a search tool and front-loads the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex search tool with 20 parameters and no output schema, the description is insufficient. It doesn't explain what results look like, how pagination works, or provide any behavioral context. With no annotations and no output schema, users must infer too much from the parameter descriptions alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 20 parameters thoroughly. The description adds only the general concept of 'various filters' without providing additional semantic context beyond what's in the parameter descriptions. This meets the baseline expectation when schema coverage is complete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search for') and target resource ('Norwegian business sub-entities (underenheter)'), providing specific domain context. However, it doesn't explicitly differentiate from sibling tools like 'search_entities' or 'get_sub_entity', which would be needed for a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'with various filters' which implies filtering capabilities, but provides no explicit guidance on when to use this tool versus alternatives like 'search_entities' or 'get_sub_entity'. No context about use cases, prerequisites, or limitations is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search voluntary organizations in the voluntary organization registry
| Name | Required | Description | Default |
|---|---|---|---|
| searchAfter | No | Search after this organization number for pagination | |
| size | No | Maximum number of organizations (default 100) | |
| spraak | No | Language for code descriptions (e.g., 'NOB') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but only states the basic action. It doesn't mention whether this is a read-only operation, how results are returned (e.g., pagination details beyond the schema), potential rate limits, authentication needs, or error conditions. For a search tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any fluff or redundant information. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a search operation with three parameters, no annotations, and no output schema, the description is incomplete. It lacks information on what the search returns (e.g., organization details, match criteria), how results are structured, or any behavioral nuances. This leaves the agent with insufficient context to use the tool effectively beyond basic invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with all three parameters clearly documented in the input schema (searchAfter for pagination, size for result limits, spraak for language). The description adds no additional parameter semantics beyond what's already in the schema, so it meets the baseline for high schema coverage without compensating value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Search') and target resource ('voluntary organizations in the voluntary organization registry'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'search_entities' or 'search_sub_entities' that might also search related data, missing an opportunity for clearer distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_voluntary_organization' (which might retrieve a single organization) or other search tools in the sibling list. There's no mention of prerequisites, typical use cases, or exclusions, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Most tools have clearly distinct purposes targeting specific resources like entities, sub-entities, municipalities, or organizational forms. However, some overlap exists between get_entity_updates and get_role_updates, which both involve updates and could cause minor confusion in selection.
All tools follow a consistent verb_noun pattern with 'get_' or 'search_' prefixes, making them predictable and easy to understand. The naming is uniform across all 15 tools without any deviations in style.
With 15 tools, the server is well-scoped for its domain of Norwegian business registry data. Each tool serves a specific function, such as retrieving, searching, or updating different entity types, and none appear redundant or unnecessary.
The toolset provides comprehensive coverage for querying and searching various registry components, including entities, sub-entities, municipalities, and organizational forms. A minor gap is the lack of update or delete operations, but this is reasonable for a read-only registry interface.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Compliance infrastructure API connecting AI agents to Norwegian government systems (Altinn, BRREG).
Norwegian company intelligence: ownership, roles, financials, risk, KYC/AML/PEP (multi-source)
Agent-native API for Finnish public company data via YTJ. Pay-per-call $0.01 USDC over x402.
Live data from 27 official national company registries. Unmodified. For KYB and due diligence.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/reidar80/BRREG-MCP'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
