Quick start

VerifyVAT provides a unified way to interpret entity IDs, validate them syntactically, check them against official registries, and return structured, normalised results suitable for onboarding, compliance, and data quality workflows.

This page shows the shortest path to a working integration, using ID verification as the entry point. Other capabilities build on the same primitives and data model.

If your language is supported, the official SDKs are the recommended integration surface. They expose the same API surface as the REST interface and add helpers to reason about results.

• SDK overview › install the SDK and understand its core concepts.
• Authentication › create and manage API keys, configure authentication.

Minimal integration flow

Most integrations start from a single, repeatable flow:

1. Receive an ID.
2. Infer its type if unknown.
3. Verify it and interpret the result.

The sections below follow this exact sequence.

Infer the ID type (optional)

If the ID type is not known in advance, you can infer it from the raw value, optionally constrained by country or region. This step is optional. If the type is already known, you can skip it.

1
curl "https://api.verifyvat.com/v1/infer-type" \
2
  -H "x-api-key: {YOUR_API_KEY}" \
3
  -H "Content-Type: application/json" \
4
  -d '{ "id": "914778271", "country": "NO" }'

1
import { createVerifyVatClient, TypeInferrer } from '@verifyvat/sdk'
2

3
const client = createVerifyVatClient()
4
const inferrer = new TypeInferrer(client)
5

6
const inference = await inferrer.inferIdType({
7
    id: '914778271',
8
    country: 'NO',
9
})
10

11
const inferredType = inferrer.pickBestInferredIdType(inference)

1
from verifyvat_sdk import VerifyVatClient, TypeInferrer
2

3
client = VerifyVatClient()
4
inferrer = TypeInferrer(client)
5

6
inference = inferrer.infer_id_type(
7
    id="914778271",
8
    country="NO",
9
)
10

11
inferred_type = inferrer.pick_best_inferred_id_type(inference)

See Infer the ID type for details on inputs, confidence scoring, and edge cases.

Verify the ID and interpret the outcome

Verification validates the ID, queries registries, optionally follows linked IDs, and merges the evidence into a single, structured result.

1
curl "https://api.verifyvat.com/v1/verify" \
2
  -H "x-api-key: {YOUR_API_KEY}" \
3
  -H "Content-Type: application/json" \
4
  -d '{ "type": "no_orgnr", "id": "914778271" }'

1
// continuing from above
2

3
import { Verifier } from '@verifyvat/sdk'
4

5
const verifier = new Verifier(client)
6

7
const verification = await verifier.verifyId({
8
    type: 'no_orgnr',
9
    id: '914778271',
10
})
11

12
const description = verifier.describeVerification(verification)

1
# continuing from above
2

3
from verifyvat_sdk import Verifier
4

5
verifier = Verifier(client)
6

7
verification = verifier.verify_id(
8
    type="no_orgnr",
9
    id="914778271",
10
)
11

12
description = verifier.describe_verification(verification)

This single operation provides:

• a verification outcome
• diagnostic issues explaining how that outcome was reached
• registry evidence and freshness information
• an entity representation when meaningful information is available

See Verify an ID for a detailed breakdown of inputs, outputs, and interpretation.
If you are using the SDK, see SDK: verify and decide for reasoning helpers and best practices.

Understanding what the result means

Verification results are designed to be consumed programmatically.

Decisions should be based on the verification outcome together with reported issues and registry evidence, rather than on the presence or absence of entity data alone.

Detailed semantics are explained in Verify an ID and mirrored by the SDK reasoning helpers.

Inspecting coverage and data sources (optional)

Some implementations need to adapt dynamically to supported ID types or registry integrations.

These endpoints are not required for a first integration, but are commonly used once the system is in place.

• List supported IDs › list ID types, formats, and coverage.
• List data sources › inspect registries, capabilities, and data freshness.