AstraNL Dutch counterparty check
Server Details
Check a Dutch supplier before you pay: KvK register, name match, VIES VAT, EU sanctions. No key.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 3 tools
Each tool has a clearly distinct role: check_counterparty_nl produces a check, record_counterparty_check attests it in the public log, and verify_astranl validates a reference. There is no overlap in purpose; the descriptions even cross-reference how the check_id flows between them.
All three follow a verb_noun pattern (check_/record_/verify_), which is predictable. The noun suffixes are inconsistent though (_nl, _check, _astranl), making the set slightly less uniform than a strict convention would be.
Three tools is on the lean side but well matched to a focused check-record-verify workflow, with each tool earning its place. Nothing extraneous and no obvious missing member of the loop.
The produce-attest-verify lifecycle for counterparty checks is fully covered, including re-verification and expiry semantics. Minor gaps (e.g. no batch check or status listing of prior checks) are workable around and not core to the purpose.
Available Tools
3 toolscheck_counterparty_nlARead-onlyIdempotentInspect
Check a Dutch or EU counterparty against official sources before your own next step, such as onboarding a supplier, paying an invoice or signing an order. Give the KvK number, the company name and the EU VAT number as your document states them. Returns verdicts, not register data: whether the KvK number has an active registration, whether the name matches a registered name, whether the VAT number is valid in VIES and whether its VIES name matches the register, EU sanctions list candidates, whether an insolvency case is published under the KvK number in the Dutch insolvency register, open questions and a check_id. Read-only, no key, no cost. AstraNL does not search the Dutch register by name; look a number up at kvk.nl. When a colleague or auditor must verify it later, call record_counterparty_check with the check_id. It does not prove who may sign for the company, who owns a bank account, solvency or reliability.
| Name | Required | Description | Default |
|---|---|---|---|
| city | No | not used; kept for compatibility, AstraNL does not search the register by name | |
| purpose | No | optional: the next action you are about to take, for example approve supplier or pay invoice | |
| kvk_number | No | Dutch KvK number, 8 digits, as printed on the invoice, quote or website | |
| vat_number | No | EU VAT number with country prefix, for example NL810433941B01 | |
| company_name | No | the company name exactly as your document or contact states it |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnly, idempotent, non-destructive, openWorld), the description adds material behavioral context: read-only with no key and no cost, that it returns verdicts rather than register data, an itemized list of what the verdicts cover, and an explicit boundary of what it cannot prove (signing authority, bank account ownership, solvency, reliability). No annotation contradiction.
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?
Purpose and pre-action framing are front-loaded, and the return enumeration earns its length because there is no output schema. It is still dense and multi-sentence; the return list and the limitations paragraph could be tightened without losing meaning.
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?
With no output schema, the description carries the full burden of describing returns and does so thoroughly (registration status, name match, VIES validity and name match, sanctions candidates, insolvency case, open questions, check_id). Safety is covered by annotations and the remaining gaps are explicitly disclosed, so an agent has everything needed to call it correctly.
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 baseline is 3, but the description adds real guidance beyond the schema: it instructs the caller to supply the KvK number, company name and EU VAT number exactly as the document states them, which matters for the name-match verdicts. It does not expand on the compatibility-only city field or the purpose field beyond what the schema already says.
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?
States a specific verb and resource (check a Dutch/EU counterparty against official sources) and pins the scope to a pre-action decision point. The description makes clear this is verification of identity/registration status rather than a generic lookup, and it is readily distinguishable from record_counterparty_check and verify_astranl.
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?
Explicit about when to invoke it ('before your own next step, such as onboarding a supplier, paying an invoice or signing an order') and names the follow-up alternative (record_counterparty_check with the check_id when a colleague or auditor must verify later). It also states the negative case: AstraNL does not search the Dutch register by name, so look a number up at kvk.nl.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
record_counterparty_checkAIdempotentInspect
Make a result of check_counterparty_nl verifiable by others: records its digest in the AstraNL signed public log and returns a reference that a colleague, approver or auditor can check later with verify_astranl, without trusting AstraNL. Works only for a check AstraNL produced in the last 48 hours. The public record holds no name, number or address of the checked party. Calling it again returns the same reference.
| Name | Required | Description | Default |
|---|---|---|---|
| check_id | Yes | the check_id returned by check_counterparty_nl, ASTRA-K- and 16 characters |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, it discloses that the record goes to a public signed log, that no name/number/address of the checked party is stored, that re-calling yields the identical reference, and that verification does not require trusting AstraNL. These are exactly the behavioral traits an agent cannot infer from readOnlyHint=false / idempotentHint=true.
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?
Three dense sentences, front-loaded with the purpose and outcome. Every clause carries distinct information: purpose, trust model, eligibility window, privacy guarantee, idempotency. No filler.
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 single-parameter write tool with no output schema, the description covers the return value ('a reference'), the downstream consumer, the freshness constraint, privacy implications, and idempotency. Nothing an agent needs to invoke it correctly 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 coverage is 100% and check_id's format is fully documented there, so the baseline is 3. The description adds a semantic constraint on the referenced check (must be produced within 48 hours) that meaningfully qualifies valid inputs, lifting it slightly.
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 states a specific verb+resource ('records its digest in the AstraNL signed public log') and defines the concrete outcome ('returns a reference that a colleague, approver or auditor can check later'). It clearly distinguishes itself from sibling check_counterparty_nl (the producer of the input) and verify_astranl (the later consumer).
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?
It explicitly names the alternative tool (verify_astranl), the audience that consumes the record (colleague, approver, auditor), and a hard eligibility window ('works only for a check AstraNL produced in the last 48 hours'). It stops short of stating an explicit when-not-to-use case beyond that window, so not quite a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
verify_astranlARead-onlyIdempotentInspect
Verify any AstraNL reference without a key. Returns two separate layers: integrity (payload hash, Ed25519 signature, Merkle inclusion, recomputed live) and claim (what exactly is attested, by whom, from which source, when, under which method, with which validity limits and current status VALID/EXPIRED/REVOKED/UNKNOWN). Integrity never implies the claim is true for your purpose; you apply your own acceptance rules. Tells you when to re-verify and how to consume a VALID receipt for a next action. Read-only, deterministic, no model in the path.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | Yes | Any AstraNL reference: action receipt ASTRA-A-..., policy receipt ASTRA-R-..., consumption ASTRA-C-..., log event alk_..., attestation att_/atr_..., ingress receipt RCPT-n |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds substantial behavioral context beyond the annotations. It discloses that the tool is deterministic, read-only, and has no model in the path. It explains the two-layer return structure (integrity with payload hash, Ed25519 signature, Merkle inclusion recomputed live; and claim with attestation details and status). It clarifies the important distinction that integrity never implies the claim is true for your purpose, which is a key behavioral trait.
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, dense paragraph that front-loads the core purpose and key outcome ('Verify any AstraNL reference without a key'). It packs a lot of information but remains focused and avoids unnecessary fluff. The length is justified by the complexity of the verification process and the need to explain the two layers and limitations.
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 and the absence of an output schema, the description provides complete context. It explains the return structure (two layers), the meaning of status values, the non-implication of integrity for claim truth, and how to act on a VALID receipt. It also clarifies the deterministic and read-only behavior, which is crucial for an agent deciding how to use the tool.
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% for the single parameter 'ref', and the schema already provides comprehensive examples of reference formats. The description does not add further parameter syntax details, which is acceptable given the high schema coverage. The baseline for 0 parameters is 4, but here there is 1 well-documented parameter, so the description's lack of additional parameter info is acceptable and warrants a 4.
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 states a specific verb (verify) and resource (any AstraNL reference) with a notable capability qualifier ('without a key'). It explains the two-layer output structure (integrity and claim), which clearly distinguishes this verification tool from the sibling tools, which appear to concern counterparty checks and records.
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 gives clear context for use: it tells you when to re-verify and how to consume a VALID receipt for a next action. It also clarifies that integrity does not imply the claim is true for your purpose, implying you must apply your own acceptance rules. However, it does not explicitly name alternatives or state when not to use this tool versus the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
check_counterparty_nl - First observed
record_counterparty_check - First observed
verify_astranl
Related MCP Connectors
Check the bank behind an IBAN before you pay: bank-code check, BIC with source, bank-level sanctions
Verify companies, domains and counterparties before transacting. Sanctions, UBO, fraud scoring.
EU compliance checks for AI agents: sanctions, company, VAT ID, IBAN, email. Pay per call.
European business verification for AI agents: registry, VAT, sanctions, IBAN. Pay-per-call x402.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceProvides free read-only business checks for IBANs, EU VAT number format, Peppol e-invoice rules, supplier bank-detail changes, and CSV/XLSX data cleaning.MIT
- FlicenseNot gradedqualityBmaintenanceCross-checks company/entity records against 23 national commercial registries (GLEIF, SIRENE, VIES, TED, Companies House) to flag missing or inconsistent registrations. Free tier: 100 calls/month via hosted API.-
- AlicenseNot gradedqualityCmaintenanceEnables querying the Dutch IND public register of recognised sponsors for work/residence permits. Offers tools to search sponsors by name or KvK number and check register status.MIT
- AlicenseNot gradedqualityBmaintenanceValidates EU, UK, and AU VAT numbers against live sources and uses AI pattern analysis to detect invoice fraud.28 npmMIT
Glama MCP Gateway
Add one secure layer between your agents and this server.