> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getcurrent.ca/llms.txt
> Use this file to discover all available pages before exploring further.

# Verify Business

> Verify customer-provided business data against Canadian business registry records.

Fetches fresh registry data, performs field-level matching with configurable thresholds,
and returns structured results with an AI-generated analyst summary.

**What gets verified:**
- **Legal name** — normalized comparison (strips corporate suffixes like Inc., Corp., Ltd.)
- **Registration number** — normalized similarity match with configurable threshold (strips formatting and jurisdiction prefixes)
- **Address** — per-field fuzzy matching (optional)
- **People** — name and role matching against registry directors/officers (enabled by default)

**Matching thresholds** are governed by your account's verification settings; a per-request
`matching` object overrides them. Out of the box (no custom settings), legal name, address, and
people default to `0.95` (fuzzy) and registration number to `1.0` (exact). A threshold of `1.0`
requires an exact (normalized) match; lower values allow proportionally fuzzier matches.

**Synchronous vs asynchronous:** when a fresh registry lookup is required this endpoint
responds with **`202 Accepted`** and a `reportFetchId` — poll
`GET /verify/{id}` until it returns the completed `VerifyResponse`. When a recent cached
registry report is available the result is returned synchronously with **`200 OK`**.
Always branch on the HTTP status (or the presence of `pending: true`) rather than assuming 200.

**Typical response time:** 20-40 seconds (registry lookup is the bottleneck)




## OpenAPI

````yaml /openapi.yaml post /verify
openapi: 3.1.0
info:
  title: Current Business Verification API
  version: 1.0.0
  description: >
    The Current API provides programmatic access to Canadian business
    verification services.


    ## Authentication

    All API requests require authentication via API key. Include your key using
    one of these methods:

    - `Authorization: Bearer cur_live_xxxxx` (recommended)

    - `X-API-Key: cur_live_xxxxx`


    ## Rate Limits

    All endpoints are rate limited to **60 requests per minute** per API key.


    Rate limit headers are included in all responses:

    - `X-RateLimit-Limit`: Maximum requests allowed in current window

    - `X-RateLimit-Remaining`: Remaining requests in current window

    - `X-RateLimit-Reset`: Unix timestamp when the rate limit resets


    ## Request IDs

    All responses include an `X-Request-Id` header for traceability.

    You can provide your own via the `X-Request-Id` request header; otherwise
    one is generated automatically.

    Include this ID when contacting support about a specific request.
  contact:
    name: Current Support
    url: https://getcurrent.ca
  license:
    name: Proprietary
servers:
  - url: https://api.getcurrent.ca/v1
    description: Production
security:
  - bearerAuth: []
  - apiKeyHeader: []
tags:
  - name: Search
    description: Business verification search operations
  - name: Pre-fill
    description: Fast typeahead lookup of canonical business candidates
  - name: Generate PDF
    description: PDF report generation
  - name: Business Reports
    description: Business report operations
  - name: Sanctions
    description: Standalone sanctions screening operations
  - name: Verification
    description: Business verification operations
  - name: Businesses
    description: >-
      Business record sync (list/read as a change feed, upsert to keep records
      current)
paths:
  /verify:
    post:
      tags:
        - Verification
      summary: Verify Business
      description: >
        Verify customer-provided business data against Canadian business
        registry records.


        Fetches fresh registry data, performs field-level matching with
        configurable thresholds,

        and returns structured results with an AI-generated analyst summary.


        **What gets verified:**

        - **Legal name** — normalized comparison (strips corporate suffixes like
        Inc., Corp., Ltd.)

        - **Registration number** — normalized similarity match with
        configurable threshold (strips formatting and jurisdiction prefixes)

        - **Address** — per-field fuzzy matching (optional)

        - **People** — name and role matching against registry
        directors/officers (enabled by default)


        **Matching thresholds** are governed by your account's verification
        settings; a per-request

        `matching` object overrides them. Out of the box (no custom settings),
        legal name, address, and

        people default to `0.95` (fuzzy) and registration number to `1.0`
        (exact). A threshold of `1.0`

        requires an exact (normalized) match; lower values allow proportionally
        fuzzier matches.


        **Synchronous vs asynchronous:** when a fresh registry lookup is
        required this endpoint

        responds with **`202 Accepted`** and a `reportFetchId` — poll

        `GET /verify/{id}` until it returns the completed `VerifyResponse`. When
        a recent cached

        registry report is available the result is returned synchronously with
        **`200 OK`**.

        Always branch on the HTTP status (or the presence of `pending: true`)
        rather than assuming 200.


        **Typical response time:** 20-40 seconds (registry lookup is the
        bottleneck)
      operationId: createVerification
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/VerifyRequest'
            examples:
              basic:
                summary: Basic verification (name and registration number)
                value:
                  legalName: Shopify Inc.
                  jurisdiction: 'ON'
                  registrationNumber: '2033076'
              byBusinessId:
                summary: Verify a stored business record by ID
                description: >
                  Pass only a `businessId` — legal name, jurisdiction,
                  registration number, address and people are hydrated from that
                  record.
                value:
                  businessId: a1b2c3d4-e5f6-7890-abcd-ef1234567890
              byBusinessExternalId:
                summary: Verify a stored business record by your own id
                description: >
                  Pass only a `businessExternalId` (the id you set on the
                  record). The business is looked up by it and its fields are
                  hydrated; an unknown id returns 404 (never creates a
                  business).
                value:
                  businessExternalId: acct_1Nxxx
              byBusinessIdWithOverride:
                summary: Verify a stored record but override one field
                description: >
                  Hydrate from the record, but verify against a different
                  address for this request only (the record is not modified).
                value:
                  businessId: a1b2c3d4-e5f6-7890-abcd-ef1234567890
                  address:
                    city: Toronto
                    province: Ontario
              withAddress:
                summary: Verification with address
                value:
                  legalName: Shopify Inc.
                  jurisdiction: 'ON'
                  registrationNumber: '2033076'
                  address:
                    city: Ottawa
                    province: Ontario
                  matching:
                    address:
                      threshold: 0.85
              withPeople:
                summary: Verification with people check
                value:
                  legalName: Shopify Inc.
                  jurisdiction: 'ON'
                  registrationNumber: '2033076'
                  people:
                    - name: Tobias Lutke
                      role: Director
                  matching:
                    people:
                      enabled: true
                      threshold: 0.85
              strictPeople:
                summary: People check that impacts verification status
                value:
                  legalName: Shopify Inc.
                  jurisdiction: 'ON'
                  registrationNumber: '2033076'
                  people:
                    - name: Tobias Lutke
                      role: Director
                  matching:
                    people:
                      enabled: true
                      threshold: 0.9
                      impactsVerification: true
      responses:
        '200':
          description: >-
            Verification completed (check `status` field — may be `verified` or
            `not_verified`)
          headers:
            X-Request-Id:
              $ref: '#/components/headers/X-Request-Id'
            X-RateLimit-Limit:
              $ref: '#/components/headers/X-RateLimit-Limit'
            X-RateLimit-Remaining:
              $ref: '#/components/headers/X-RateLimit-Remaining'
            X-RateLimit-Reset:
              $ref: '#/components/headers/X-RateLimit-Reset'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/VerifyResponse'
              examples:
                verified:
                  summary: Verified — all fields matched
                  value:
                    meta:
                      verificationId: a1b2c3d4-e5f6-7890-abcd-ef1234567890
                      verifiedAt: '2026-02-21T12:00:00.000Z'
                      duration: 23400
                      submitted:
                        legalName: Shopify Inc.
                        jurisdiction: 'ON'
                        registrationNumber: '2033076'
                        address: null
                    results:
                      status: verified
                      fields:
                        legalName:
                          status: matched
                          score: 1
                          provided: Shopify Inc.
                          registry: SHOPIFY INC.
                        registrationNumber:
                          status: matched
                          score: 1
                          provided: '2033076'
                          registry: '2033076'
                        address: null
                      analystSummary: >-
                        Verification passed for Shopify Inc. (ON-2033076). The
                        legal name and registration number matched the Canadian
                        business registry exactly. The business is currently
                        active and in good standing. No further action is
                        required.
                    registryData:
                      legalName: SHOPIFY INC.
                      registrationNumber: '2033076'
                      jurisdiction: Ontario
                      status: Active
                      goodStanding: true
                      addresses:
                        - street: 150 Elgin Street
                          city: Ottawa
                          province: Ontario
                          postalCode: K2P 1L4
                          country: Canada
                          raw: null
                      people:
                        - name: Tobias Lutke
                          titles:
                            - Director
                          addresses: []
                notVerified:
                  summary: Not verified — registration number mismatch
                  value:
                    meta:
                      verificationId: b2c3d4e5-f6a7-8901-bcde-f12345678901
                      verifiedAt: '2026-02-21T12:01:00.000Z'
                      duration: 24100
                      submitted:
                        legalName: Shopify Inc.
                        jurisdiction: 'ON'
                        registrationNumber: '9999999'
                        address: null
                    results:
                      status: not_verified
                      fields:
                        legalName:
                          status: matched
                          score: 1
                          provided: Shopify Inc.
                          registry: SHOPIFY INC.
                        registrationNumber:
                          status: not_matched
                          score: 0.43
                          provided: '9999999'
                          registry: '2033076'
                        address: null
                      analystSummary: >-
                        Verification failed for Shopify Inc. (ON-9999999). The
                        registration number provided (9999999) does not match
                        the registry record (2033076). The legal name matched,
                        but the registration number discrepancy is a significant
                        concern. Manual review and confirmation of the correct
                        registration number is recommended before proceeding.
                    registryData:
                      legalName: SHOPIFY INC.
                      registrationNumber: '2033076'
                      jurisdiction: Ontario
                      status: Active
                      goodStanding: true
                      addresses: []
                      people: []
        '202':
          description: |
            Verification accepted and running asynchronously (a fresh registry
            lookup was required). Poll `GET /verify/{id}` using the returned
            `reportFetchId` until it completes.
          headers:
            X-Request-Id:
              $ref: '#/components/headers/X-Request-Id'
            X-RateLimit-Limit:
              $ref: '#/components/headers/X-RateLimit-Limit'
            X-RateLimit-Remaining:
              $ref: '#/components/headers/X-RateLimit-Remaining'
            X-RateLimit-Reset:
              $ref: '#/components/headers/X-RateLimit-Reset'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/VerifyPendingResponse'
              example:
                pending: true
                reportFetchId: a1b2c3d4-e5f6-7890-abcd-ef1234567890
                status: pending
                statusUrl: /v1/verify/a1b2c3d4-e5f6-7890-abcd-ef1234567890
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '404':
          description: |
            A `businessId` or `businessExternalId` was provided but does not
            reference a business record belonging to your tenant.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error: businessId not found
                code: NOT_FOUND
        '429':
          $ref: '#/components/responses/RateLimited'
        '500':
          $ref: '#/components/responses/InternalError'
      security:
        - bearerAuth: []
        - apiKeyHeader: []
components:
  schemas:
    VerifyRequest:
      type: object
      anyOf:
        - required:
            - legalName
            - jurisdiction
            - registrationNumber
        - required:
            - businessId
        - required:
            - businessExternalId
      description: >
        Supply the identity fields directly, or reference one of your stored
        business records by `businessId` (our id) or `businessExternalId` (your
        own id on the record) — its legal name, jurisdiction, registration
        number (and address / people) are hydrated from that record. Any field
        you also supply in the request overrides the record for this
        verification only; the stored record is never modified.
      properties:
        businessId:
          type: string
          format: uuid
          description: >
            Verify one of your existing business records. When provided,
            `legalName` / `jurisdiction` / `registrationNumber` (and address /
            people) become optional and are taken from the record. Must
            reference a business owned by your tenant, otherwise the request
            fails with `404 NOT_FOUND`. If the record is missing a required
            identity field the request fails with `400`.
        businessExternalId:
          type: string
          description: >
            Reference a stored business record by your own id on it (its
            `external_id`) instead of `businessId` — same behavior. Unknown id →
            `404 NOT_FOUND` (never creates a business). If both `businessId` and
            `businessExternalId` are supplied they must point at the same
            record, otherwise `400`. (Distinct from `externalId`, which is
            result metadata, not a lookup.)
        legalName:
          type: string
          description: >
            Legal name of the business to verify. Required unless `businessId`
            or `businessExternalId` is provided.
          example: Shopify Inc.
        jurisdiction:
          type: string
          description: >
            Canadian jurisdiction code (AB, BC, MB, NB, NL, NS, NT, NU, ON, PE,
            QC, SK, YT, FED) or full name (e.g. "Ontario", "British Columbia",
            "Federal"). Required unless `businessId` or `businessExternalId` is
            provided.
          example: 'ON'
        registrationNumber:
          type: string
          description: >
            Business registration number assigned by the provincial or federal
            registry. Required unless `businessId` or `businessExternalId` is
            provided.
          example: '2033076'
        address:
          $ref: '#/components/schemas/VerifyAddress'
        people:
          type: array
          items:
            $ref: '#/components/schemas/VerifyPerson'
          description: >
            People to verify against registry directors/officers. People
            matching is enabled by default; set `matching.people.enabled: false`
            to skip it.
        externalId:
          type: string
          description: >
            Your own reference id for this verification (e.g. a CRM record id).
            Recorded as metadata on the verification RESULT so you can find
            verifications by your own identifiers. This is NOT a business lookup
            and never modifies the business record — to reference a stored
            business by your own id, use `businessExternalId`.
          example: ref_1Nxxx
        matching:
          $ref: '#/components/schemas/VerifyMatchingConfig'
    VerifyResponse:
      type: object
      required:
        - meta
        - results
        - registryData
      properties:
        meta:
          $ref: '#/components/schemas/VerifyMeta'
        results:
          type: object
          required:
            - status
            - fields
            - analystSummary
          properties:
            status:
              type: string
              enum:
                - verified
                - not_verified
              description: >
                `verified` when legal name, registration number, and address (if
                provided) all meet their thresholds. People results only affect
                status when `matching.people.impactsVerification` is true.
            fields:
              $ref: '#/components/schemas/VerifyFields'
            analystSummary:
              type: string
              description: >-
                AI-generated natural language summary of the verification
                result, written for a compliance analyst
        registryData:
          $ref: '#/components/schemas/VerifyRegistryData'
    VerifyPendingResponse:
      type: object
      description: >
        Returned by `POST /verify` (as `202`) and by `GET /verify/{id}` while
        the verification is still running. Keep polling `GET /verify/{id}` until
        you receive a `VerifyResponse` or a `VerifyFailedResponse`.
      required:
        - pending
        - status
      properties:
        pending:
          type: boolean
          enum:
            - true
        reportFetchId:
          type: string
          format: uuid
          description: >-
            Identifier to poll — only present on the initial `202` from `POST
            /verify`
        status:
          type: string
          enum:
            - pending
            - processing
            - waiting_for_registry
        statusUrl:
          type: string
          description: >-
            Relative URL to poll for the result (only present on the initial
            `202`)
          example: /v1/verify/a1b2c3d4-e5f6-7890-abcd-ef1234567890
        scheduledFor:
          type: string
          format: date-time
          nullable: true
          description: When the next processing attempt is scheduled, if delayed
    ErrorResponse:
      type: object
      required:
        - error
        - code
      properties:
        error:
          type: string
          description: Human-readable error message
        code:
          type: string
          description: >
            Machine-readable error code. Present on every error response.
            Distinct from the per-source `APIError.code` values that appear
            inside a successful response's `meta.errors` object.
          enum:
            - MISSING_API_KEY
            - INVALID_API_KEY
            - REVOKED_API_KEY
            - EXPIRED_API_KEY
            - RATE_LIMITED
            - VALIDATION_ERROR
            - INVALID_JSON
            - NOT_FOUND
            - STALE_WRITE
            - CONFLICT
            - METHOD_NOT_ALLOWED
            - UNAUTHORIZED
            - SERVER_ERROR
            - INTERNAL_ERROR
          example: VALIDATION_ERROR
    VerifyAddress:
      type: object
      description: >-
        Address fields to verify against the registry. All fields are optional —
        only provided fields are compared.
      properties:
        street:
          type: string
          example: 150 Elgin Street
        city:
          type: string
          example: Ottawa
        province:
          type: string
          description: Full province name or code (e.g. "Ontario" or "ON")
          example: Ontario
        postalCode:
          type: string
          description: >-
            Postal code — spacing is normalized (e.g. "K2P1L4" and "K2P 1L4" are
            treated as equal)
          example: K2P 1L4
        country:
          type: string
          example: Canada
    VerifyPerson:
      type: object
      required:
        - name
        - role
      properties:
        name:
          type: string
          example: Tobias Lutke
        role:
          type: string
          description: Role to verify (e.g. "Director", "Officer", "Shareholder")
          example: Director
    VerifyMatchingConfig:
      type: object
      description: >
        Per-request overrides for your account's verification settings. The
        `default` shown on each field is the out-of-the-box value used when you
        haven't customized your account settings and omit the field here.
      properties:
        legalName:
          type: object
          properties:
            threshold:
              type: number
              minimum: 0
              maximum: 1
              default: 0.95
              description: Minimum similarity score for legal name to be considered matched
        registrationNumber:
          type: object
          properties:
            threshold:
              type: number
              minimum: 0
              maximum: 1
              default: 1
              description: >-
                Minimum similarity score for registration number to be
                considered matched
        address:
          type: object
          properties:
            threshold:
              type: number
              minimum: 0
              maximum: 1
              default: 0.95
              description: >-
                Minimum per-field similarity score for address fields to be
                considered matched
            required:
              type: boolean
              default: true
              description: Whether an address mismatch causes overall `not_verified`
        status:
          type: object
          description: >-
            Matching config for a submitted registration `status` (only applies
            when `status` is submitted)
          properties:
            threshold:
              type: number
              minimum: 0
              maximum: 1
              default: 1
            required:
              type: boolean
              default: false
        businessNumber:
          type: object
          description: >-
            Matching config for a submitted `businessNumber` (only applies when
            submitted)
          properties:
            threshold:
              type: number
              minimum: 0
              maximum: 1
              default: 1
            required:
              type: boolean
              default: false
        entityType:
          type: object
          description: >-
            Matching config for a submitted `entityType` (only applies when
            submitted)
          properties:
            threshold:
              type: number
              minimum: 0
              maximum: 1
              default: 1
            required:
              type: boolean
              default: false
        people:
          type: object
          properties:
            enabled:
              type: boolean
              default: true
              description: Whether to run people verification
            threshold:
              type: number
              minimum: 0
              maximum: 1
              default: 0.95
              description: >-
                Minimum name similarity score for a person to be considered
                matched
            impactsVerification:
              type: boolean
              default: true
              description: Whether people match results affect the overall `status` field
            requiredMatchLevel:
              type: string
              enum:
                - all_matched
                - partial_match
              default: all_matched
              description: >
                Minimum people match level required for verification when
                `impactsVerification` is true. `all_matched` requires every
                submitted person to match name and role. `partial_match`
                requires at least one match (name-only or role mismatch still
                counts).
            personMatchRequires:
              type: string
              enum:
                - name
                - both
              default: name
              description: >
                What a single person must match to count. `name` requires only a
                name match; `both` requires name and role to match.
        normalization:
          type: object
          properties:
            enabled:
              type: boolean
              default: true
              description: >
                When true (default), values are normalized before comparison to
                handle common formatting differences. When false, raw
                character-for-character comparison is used with no
                transformations.


                **Legal name normalization:**

                - Unicode canonicalization (NFC) and smart quote normalization

                - `&` expanded to `and`; connector words (`and`, `et`) stripped

                - Corporate suffixes stripped (Inc, Ltd, Ltée, Corp, LLC, LLP,
                Co, Cie, S.E.N.C.R.L., etc.)

                - Hyphens and dashes converted to spaces

                - Punctuation removed, case-insensitive


                **Registration number normalization:**

                - Jurisdiction prefix stripped (e.g. `ON-`, `BC_`)

                - Formatting characters removed (hyphens, spaces, dots, slashes)

                - Leading zeros stripped


                **Address normalization:**

                - Street types abbreviated (Street→St, Avenue→Ave,
                Boulevard→Blvd, Road→Rd, Drive→Dr, Rue→St, etc.)

                - Province full names mapped to 2-letter codes (Ontario→ON,
                Québec→QC, etc.)

                - Country variants mapped to ISO code (Canada→CA)

                - Postal code spacing normalized (K2P 1L4 = K2P1L4)

                - Punctuation removed, case-insensitive


                **People name normalization:**

                - Unicode canonicalization (NFC) and smart quote normalization

                - Punctuation removed, case-insensitive
    VerifyMeta:
      type: object
      required:
        - verificationId
        - verifiedAt
        - duration
        - submitted
      properties:
        verificationId:
          type: string
          format: uuid
          description: Unique identifier for this verification request
        verifiedAt:
          type: string
          format: date-time
          description: ISO 8601 timestamp of when the verification was run
        duration:
          type: integer
          description: Total verification time in milliseconds
        submitted:
          type: object
          required:
            - legalName
            - jurisdiction
            - registrationNumber
          properties:
            legalName:
              type: string
              description: Legal name as submitted in the request
            jurisdiction:
              type: string
              description: Jurisdiction code as submitted
            registrationNumber:
              type: string
              description: Registration number as submitted
            status:
              type: string
              description: Business status as submitted in the request (optional)
            address:
              $ref: '#/components/schemas/VerifyAddress'
              nullable: true
              description: Address as submitted in the request (null if not provided)
            people:
              type: array
              nullable: true
              items:
                $ref: '#/components/schemas/VerifyPerson'
              description: People as submitted in the request (null if not provided)
        matching:
          $ref: '#/components/schemas/VerifyMatchingConfig'
          description: >-
            Resolved matching configuration used for this verification
            (thresholds with defaults applied)
    VerifyFields:
      type: object
      required:
        - legalName
        - registrationNumber
      properties:
        legalName:
          $ref: '#/components/schemas/FieldMatch'
        registrationNumber:
          $ref: '#/components/schemas/FieldMatch'
        status:
          $ref: '#/components/schemas/FieldMatch'
          nullable: true
        businessNumber:
          $ref: '#/components/schemas/FieldMatch'
          nullable: true
          description: Present only when a `businessNumber` was submitted
        entityType:
          $ref: '#/components/schemas/FieldMatch'
          nullable: true
          description: Present only when an `entityType` was submitted
        address:
          $ref: '#/components/schemas/AddressMatch'
          nullable: true
        people:
          $ref: '#/components/schemas/VerifyPeopleResult'
    VerifyRegistryData:
      type: object
      description: Registry data fetched and used for verification
      required:
        - legalName
        - registrationNumber
        - addresses
        - people
      properties:
        legalName:
          type: string
          description: Official legal name from the registry
        registrationNumber:
          type: string
          description: Registration number from the registry
        jurisdiction:
          type:
            - string
            - 'null'
          description: >
            Registry jurisdiction. When available this is the full jurisdiction
            name (e.g. "Ontario", "Federal"); otherwise it may be the
            jurisdiction code from the request (e.g. "ON", "FEDERAL").
        status:
          type:
            - string
            - 'null'
          description: Registration status (e.g. "Active", "Dissolved")
        goodStanding:
          type:
            - boolean
            - 'null'
          description: Whether the business is in good standing with the registry
        entityType:
          type:
            - string
            - 'null'
          description: Registry entity type, when available
        businessNumber:
          type:
            - string
            - 'null'
          description: CRA business number (BN), when available
        addresses:
          type: array
          items:
            $ref: '#/components/schemas/Address'
          description: Business addresses from the registry
        people:
          type: array
          items:
            $ref: '#/components/schemas/BusinessReportPerson'
          description: Directors, officers, and shareholders from the registry
        nameHistory:
          type: array
          items:
            $ref: '#/components/schemas/NameHistoryEntry'
          description: Prior legal names, when available
        naicsClassification:
          type: array
          items:
            $ref: '#/components/schemas/NaicsEntry'
          description: NAICS industry classifications, when available
        yearOfLastAnnualReturn:
          type: string
          description: Year of the most recent annual return filed, when available
        annualReturnDueDate:
          type: string
          description: Due date of the next annual return, when available
        annualReturnStatus:
          type: string
          description: Status of the annual return filing, when available
        reportUrl:
          type:
            - string
            - 'null'
          description: >-
            Signed URL to the persisted registry report PDF, when a report was
            fetched
        reportUrlExpiresAt:
          type:
            - string
            - 'null'
          description: Expiry timestamp of `reportUrl`
    FieldMatch:
      type: object
      required:
        - status
        - score
        - provided
        - registry
      properties:
        status:
          type: string
          enum:
            - matched
            - not_matched
            - not_submitted
        score:
          type: number
          minimum: 0
          maximum: 1
          description: Similarity score between the provided and registry values (0–1)
        provided:
          type: string
          description: Value as submitted in the request
        registry:
          type: string
          description: Value from the business registry
    AddressMatch:
      type: object
      nullable: true
      description: Address match result — null when no address was provided in the request
      required:
        - status
        - score
        - fields
      properties:
        status:
          type: string
          enum:
            - matched
            - partial_match
            - not_matched
            - not_submitted
          description: >
            `matched` when all submitted fields meet the threshold and the
            registry has no additional fields. `partial_match` when some
            submitted fields match, or registry has fields that were not
            submitted. `not_matched` when no submitted fields meet the
            threshold. `not_submitted` when no address was provided in the
            request.
        score:
          type: number
          minimum: 0
          maximum: 1
          description: >-
            Average similarity score across fields where both sides were present
            (excludes registry-only extras)
        fields:
          $ref: '#/components/schemas/AddressFieldMatches'
    VerifyPeopleResult:
      type: object
      nullable: true
      description: >-
        People verification results — null when `matching.people.enabled` is
        false (the default)
      required:
        - status
        - impactsVerification
        - matches
      properties:
        status:
          type: string
          enum:
            - all_matched
            - partial_match
            - no_matches
            - not_submitted
          description: >
            `all_matched`: all submitted people matched by name and role, with
            no unsubmitted registry people. `partial_match`: any discrepancy — a
            submitted person not found, a role mismatch, or registry has
            additional people not submitted. `no_matches`: none of the submitted
            people were found by name in the registry.
        impactsVerification:
          type: boolean
          description: >
            Whether this result affected the overall `status` field. When true,
            only `all_matched` passes — `partial_match` and `no_matches` result
            in `not_verified`.
        matches:
          type: array
          description: >
            All people — both submitted and registry-only. Submitted people not
            found have `registry: null`. Registry people not submitted have
            `provided: null` and `score: 0`.
          items:
            $ref: '#/components/schemas/PersonMatch'
    Address:
      type: object
      description: Business address with structured nullable fields
      properties:
        street:
          type:
            - string
            - 'null'
        city:
          type:
            - string
            - 'null'
        province:
          type:
            - string
            - 'null'
          description: Full province name (e.g., "Ontario", "British Columbia")
        postalCode:
          type:
            - string
            - 'null'
        country:
          type:
            - string
            - 'null'
          description: Full country name (e.g., "Canada")
        raw:
          type:
            - string
            - 'null'
          description: Original unstructured address string from the source
    BusinessReportPerson:
      type: object
      required:
        - name
        - titles
        - addresses
      properties:
        name:
          type: string
          description: Full name
        titles:
          type: array
          items:
            type: string
          description: Roles (e.g., "Director", "Officer", "Shareholder")
        ownership:
          type:
            - string
            - 'null'
          description: >-
            Equity/ownership details for ISC parties (e.g., "At least 25% and up
            to 50% of the shares")
        addresses:
          type: array
          items:
            $ref: '#/components/schemas/Address'
          description: Person's addresses (empty array if none)
    NameHistoryEntry:
      type: object
      required:
        - type
        - name
      properties:
        type:
          type: string
          description: Relationship type (e.g., "Trade Name", "Former Name")
        name:
          type: string
        effectiveDate:
          type:
            - string
            - 'null'
        endDate:
          type:
            - string
            - 'null'
    NaicsEntry:
      type: object
      required:
        - code
      properties:
        code:
          type: string
          description: NAICS industry code
        description:
          type: string
          description: NAICS description
    AddressFieldMatches:
      type: object
      description: >
        Per-field match results. Null only when the field is absent on both
        sides. Fields present in the registry but not submitted appear with
        `provided: null`. Fields submitted but absent in the registry appear
        with `registry: null`.
      properties:
        street:
          $ref: '#/components/schemas/AddressFieldMatch'
        city:
          $ref: '#/components/schemas/AddressFieldMatch'
        province:
          $ref: '#/components/schemas/AddressFieldMatch'
        postalCode:
          $ref: '#/components/schemas/AddressFieldMatch'
        country:
          $ref: '#/components/schemas/AddressFieldMatch'
    PersonMatch:
      type: object
      required:
        - status
        - score
        - provided
        - registry
      properties:
        status:
          type: string
          enum:
            - matched
            - partial_match
            - not_matched
          description: >
            `matched`: name met threshold and role matched registry titles.
            `partial_match`: name met threshold but role did not match.
            `not_matched`: name did not meet threshold, or `score: 0` for
            registry-only entries.
        score:
          type: number
          minimum: 0
          maximum: 1
          description: >-
            Name similarity score (0–1). Always 0 for registry-only entries
            (`provided: null`).
        provided:
          type: object
          nullable: true
          description: >-
            The submitted person's details. Null for registry people not in the
            submitted list.
          required:
            - name
            - role
          properties:
            name:
              type: string
            role:
              type: string
        registry:
          type: object
          nullable: true
          description: >-
            The matched registry person's details. Null when the submitted
            person was not found.
          required:
            - name
            - titles
          properties:
            name:
              type: string
            titles:
              type: array
              items:
                type: string
              description: Roles from the registry (e.g. ["Director", "Officer"])
    AddressFieldMatch:
      type: object
      required:
        - status
        - score
        - provided
        - registry
      properties:
        status:
          type: string
          enum:
            - matched
            - not_matched
            - not_submitted
        score:
          type: number
          minimum: 0
          maximum: 1
          description: Similarity score (0–1). Always 0 when either side is null.
        provided:
          type: string
          nullable: true
          description: >-
            Value as submitted in the request. Null when this field was not
            submitted.
        registry:
          type: string
          nullable: true
          description: >-
            Value from the business registry. Null when the registry does not
            have this field.
  headers:
    X-Request-Id:
      description: >-
        Unique request identifier for traceability. Echoes client-provided value
        or auto-generated UUID.
      schema:
        type: string
        format: uuid
        example: a1b2c3d4-e5f6-7890-abcd-ef1234567890
    X-RateLimit-Limit:
      description: Maximum requests per minute
      schema:
        type: integer
        example: 60
    X-RateLimit-Remaining:
      description: Remaining requests in current window
      schema:
        type: integer
        example: 58
    X-RateLimit-Reset:
      description: Unix timestamp when rate limit resets
      schema:
        type: integer
        example: 1702915200
  responses:
    BadRequest:
      description: Invalid request parameters
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            error: name is required and must be a non-empty string
            code: VALIDATION_ERROR
    Unauthorized:
      description: Missing or invalid API key
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          examples:
            missing:
              value:
                error: >-
                  Missing API key. Provide via Authorization: Bearer <key> or
                  X-API-Key header.
                code: MISSING_API_KEY
            invalid:
              value:
                error: Invalid API key
                code: INVALID_API_KEY
            revoked:
              value:
                error: API key has been revoked
                code: REVOKED_API_KEY
            expired:
              value:
                error: API key has expired
                code: EXPIRED_API_KEY
    RateLimited:
      description: Rate limit exceeded
      headers:
        X-RateLimit-Limit:
          $ref: '#/components/headers/X-RateLimit-Limit'
        X-RateLimit-Remaining:
          schema:
            type: integer
            example: 0
        X-RateLimit-Reset:
          $ref: '#/components/headers/X-RateLimit-Reset'
        Retry-After:
          description: Seconds until rate limit resets
          schema:
            type: integer
            example: 60
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            error: Rate limit exceeded. Try again in 60 seconds.
            code: RATE_LIMITED
    InternalError:
      description: Internal server error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            error: Internal server error
            code: SERVER_ERROR
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: 'API key as Bearer token: `Authorization: Bearer cur_live_xxxxx`'
    apiKeyHeader:
      type: apiKey
      in: header
      name: X-API-Key
      description: 'API key in header: `X-API-Key: cur_live_xxxxx`'

````