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

# Full records for a list of companies

> Return the full company record for up to 1,000 company ids in one response. Each company costs 1 credit the first time your account gets it and is free after; a repeated id is charged once and an id that matches no company is free and listed in `not_found`. All or nothing: if the account cannot pay for every new company, nothing is delivered and nothing is charged (402 with the exact number needed). `dry_run: true` returns the quote instead — how many are new, already yours or not found, the credits needed and available, and the fields you would get — and charges nothing.



## OpenAPI

````yaml /openapi.json post /v1/companies
openapi: 3.1.0
info:
  title: DataDingo API
  description: Company enrichment API.
  version: 1.0.0
  termsOfService: https://datadingo.com/terms
servers:
  - url: https://api.datadingo.com
security:
  - bearerAuth: []
paths:
  /v1/companies:
    post:
      tags:
        - Company
      summary: Full records for a list of companies
      description: >-
        Return the full company record for up to 1,000 company ids in one
        response. Each company costs 1 credit the first time your account gets
        it and is free after; a repeated id is charged once and an id that
        matches no company is free and listed in `not_found`. All or nothing: if
        the account cannot pay for every new company, nothing is delivered and
        nothing is charged (402 with the exact number needed). `dry_run: true`
        returns the quote instead — how many are new, already yours or not
        found, the credits needed and available, and the fields you would get —
        and charges nothing.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              additionalProperties: false
              type: object
              required:
                - ids
              properties:
                ids:
                  minItems: 1
                  maxItems: 1000
                  description: >-
                    DataDingo company ids (the `id` on every card). At most
                    1000. A repeated id is delivered and charged once; an id
                    that matches no company is free and listed in `not_found`.
                  type: array
                  items:
                    minLength: 1
                    maxLength: 100
                    type: string
                dry_run:
                  description: >-
                    true = return the quote only (how many are new, already
                    yours or not found, the credits needed and available, and
                    the fields you would get) and charge nothing.
                  type: boolean
      responses:
        '200':
          description: Default Response
          content:
            application/json:
              schema:
                anyOf:
                  - description: Full company records for the requested ids
                    type: object
                    required:
                      - companies
                      - not_found
                      - charged
                      - already_yours
                    properties:
                      companies:
                        description: >-
                          One full card per found id, in the order the ids were
                          first given.
                        type: array
                        items:
                          description: Full company profile with enrichment data
                          type: object
                          required:
                            - id
                            - name
                            - legal_entity
                            - website
                            - domain
                            - description
                            - tagline
                            - logo
                            - linkedin
                            - year_founded
                            - hq_location
                            - hq_country
                            - web_status
                            - web_last_verified_at
                            - locations
                            - states
                            - locations_total
                            - employee_range
                            - employee_range_source
                            - specialties
                            - specialties_total
                            - phones
                            - emails
                            - social_media
                            - industry
                            - signals
                          properties:
                            id:
                              description: >-
                                Deterministic DataDingo company ID (ADR-0014) —
                                one record per website, derived by hashing the
                                host that owns it. Stable across rebuilds for as
                                long as that host is the same; `domain` is the
                                human-readable label for the same thing.
                              type: string
                            name:
                              description: >-
                                Display name — the LinkedIn organisation's name
                                for host-first records, falling back to the
                                record host.
                              type: string
                            legal_entity:
                              anyOf:
                                - description: >-
                                    The legal entity operating this website, as
                                    Australian registers describe it. Null when
                                    — and only when — no ABN is attached to the
                                    record: the website is the record, the
                                    entity is an attribute of it.
                                    `match.confidence` says how much to trust
                                    the link.
                                  type: object
                                  required:
                                    - abn
                                    - acn
                                    - legal_name
                                    - entity_type
                                    - entity_type_code
                                    - abn_status
                                    - abn_status_date
                                    - gst_status
                                    - asic_status
                                    - asic_deregistration_date
                                    - year_registered
                                    - trading_names
                                    - trading_names_total
                                    - trustee
                                    - revenue_range
                                    - total_income_aud
                                    - total_income_year
                                    - rdti
                                    - ndis
                                    - match
                                  properties:
                                    abn:
                                      anyOf:
                                        - description: >-
                                            Australian Business Number (11 digits)
                                            of the legal entity operating this
                                            website — the record's ABN, and the only
                                            place the ABN is served. The whole
                                            `legal_entity` block is null when no ABN
                                            is attached;
                                            `legal_entity.match.confidence` says how
                                            much to trust the link.
                                          type: string
                                        - type: 'null'
                                    acn:
                                      description: >-
                                        Australian Company Number (9 digits) of
                                        THIS entity. Null for
                                        non-ASIC-registered entities (sole
                                        traders, trusts, partnerships,
                                        government bodies, unincorporated
                                        associations). A trust's corporate
                                        trustee has its own ACN, served under
                                        `trustee`, never here.
                                      anyOf:
                                        - type: string
                                        - type: 'null'
                                    legal_name:
                                      anyOf:
                                        - description: >-
                                            The entity's registered legal name —
                                            often different from the trading/brand
                                            name served as `name`. For most entities
                                            this is the name the ABR holds. For a
                                            sole trader or a partnership (ordinary,
                                            family or limited) it is the entity's
                                            first registered business name instead,
                                            because the ABR name there is a person's
                                            name; null when it has none.
                                          type: string
                                        - type: 'null'
                                    entity_type:
                                      anyOf:
                                        - description: >-
                                            Entity type exactly as the register
                                            words it — the ABR's entity-type
                                            description (e.g. 'Australian Public
                                            Company', 'Discretionary Trading Trust',
                                            'Individual/Sole Trader'). Never a
                                            bucketed or self-declared label; for the
                                            company's own self-declared ownership
                                            wording see `linkedin.ownership_type`.
                                          type: string
                                        - type: 'null'
                                    entity_type_code:
                                      anyOf:
                                        - description: >-
                                            The ABR's entity-type code behind
                                            `entity_type` (e.g. 'PUB', 'PRV',
                                            'IND').
                                          type: string
                                        - type: 'null'
                                    abn_status:
                                      anyOf:
                                        - description: >-
                                            ABN status as a word — 'active' or
                                            'cancelled' — translated from the ABR's
                                            status code. Null when the row carries
                                            no status or a code the ABR table does
                                            not know (never the raw code).
                                          anyOf:
                                            - type: string
                                              enum:
                                                - active
                                            - type: string
                                              enum:
                                                - cancelled
                                        - type: 'null'
                                    abn_status_date:
                                      anyOf:
                                        - description: >-
                                            Date (YYYY-MM-DD) the ABN entered its
                                            current status.
                                          type: string
                                        - type: 'null'
                                    gst_status:
                                      anyOf:
                                        - description: >-
                                            GST registration status as a word —
                                            'active', 'cancelled' or 'not
                                            registered' — translated from the ABR's
                                            GST status code. Data, not a filter — a
                                            business may be legitimately
                                            unregistered. Null when the row carries
                                            no status or an unknown code (never the
                                            raw code).
                                          anyOf:
                                            - type: string
                                              enum:
                                                - active
                                            - type: string
                                              enum:
                                                - cancelled
                                            - type: string
                                              enum:
                                                - not registered
                                        - type: 'null'
                                    asic_status:
                                      anyOf:
                                        - description: >-
                                            ASIC company status as a word —
                                            'registered', 'deregistered',
                                            'strike-off in progress', 'external
                                            administration', 'not active',
                                            'cancelled' or 'dissolved' — translated
                                            from ASIC's status code. Null for a
                                            non-company or an unknown code (never
                                            the raw code).
                                          anyOf:
                                            - type: string
                                              enum:
                                                - registered
                                            - type: string
                                              enum:
                                                - deregistered
                                            - type: string
                                              enum:
                                                - strike-off in progress
                                            - type: string
                                              enum:
                                                - external administration
                                            - type: string
                                              enum:
                                                - not active
                                            - type: string
                                              enum:
                                                - cancelled
                                            - type: string
                                              enum:
                                                - dissolved
                                        - type: 'null'
                                    asic_deregistration_date:
                                      anyOf:
                                        - description: >-
                                            ASIC deregistration date (YYYY-MM-DD) if
                                            deregistered.
                                          type: string
                                        - type: 'null'
                                    year_registered:
                                      anyOf:
                                        - description: >-
                                            The year this entity was registered with
                                            an Australian register — ASIC company
                                            registration, else the date its ABN's
                                            current active status began (for an ABN
                                            that was cancelled and later
                                            reactivated, that is the reactivation
                                            year, not the year the ABN was first
                                            issued). Registry-attested, and a
                                            different question from the top-level
                                            `year_founded`: the two agree exactly
                                            for only 38.8% of companies that state
                                            both.
                                          type: integer
                                        - type: 'null'
                                    trading_names:
                                      description: >-
                                        Known trading or business names
                                        registered against this entity, at most
                                        10: the names that match this website or
                                        its display name first, then the rest —
                                        `trading_names_total` says how many
                                        there are (`lookup_by_name` searches all
                                        of them). Empty array when it has none.
                                      default: []
                                      type: array
                                      items:
                                        type: string
                                    trading_names_total:
                                      description: >-
                                        How many trading or business names are
                                        registered against this entity. Larger
                                        than the length of `trading_names` when
                                        the list was cut; 0 when it has none.
                                      type: integer
                                    trustee:
                                      description: >-
                                        The corporate trustee behind a trust — a
                                        separate legal entity from this one.
                                        Null for every non-trust record, and for
                                        a trust with no known corporate trustee.
                                      anyOf:
                                        - description: >-
                                            The trust's corporate trustee: the
                                            company that acts for the trust and
                                            signs on its behalf. It is a DIFFERENT,
                                            separate legal entity from the trust
                                            this block describes, so these are the
                                            trustee company's name and ACN, not the
                                            trust's (the trust's own `acn` is null).
                                          type: object
                                          required:
                                            - name
                                            - acn
                                          properties:
                                            name:
                                              anyOf:
                                                - description: >-
                                                    The trustee company's full registered
                                                    name, as ASIC holds it (e.g. 'COMMAIR
                                                    PTY LTD'). Null when ASIC carries no
                                                    name for that ACN.
                                                  type: string
                                                - type: 'null'
                                            acn:
                                              description: >-
                                                The trustee company's own Australian
                                                Company Number (9 digits).
                                              type: string
                                        - type: 'null'
                                    revenue_range:
                                      anyOf:
                                        - description: >-
                                            Band of the entity's total income from
                                            the ATO corporate tax transparency
                                            report (published only for entities at
                                            or above the ATO reporting threshold,
                                            ≥$100M in recent years);
                                            total_income_aud beside it is the exact
                                            figure and total_income_year the income
                                            year it is from — the entity's newest
                                            reported year, however old.
                                          anyOf:
                                            - type: string
                                              enum:
                                                - <$1M
                                            - type: string
                                              enum:
                                                - $1M-$10M
                                            - type: string
                                              enum:
                                                - $10M-$50M
                                            - type: string
                                              enum:
                                                - $50M-$100M
                                            - type: string
                                              enum:
                                                - $100M-$250M
                                            - type: string
                                              enum:
                                                - $250M-$500M
                                            - type: string
                                              enum:
                                                - $500M-$1B
                                            - type: string
                                              enum:
                                                - $1B-$10B
                                            - type: string
                                              enum:
                                                - $10B+
                                        - type: 'null'
                                    total_income_aud:
                                      anyOf:
                                        - description: >-
                                            This entity's OWN total income (AUD)
                                            from the ATO corporate tax transparency
                                            report — the exact figure behind
                                            `revenue_range`, from the income year in
                                            `total_income_year`. Never a corporate
                                            group's consolidated figure.
                                          type: integer
                                        - type: 'null'
                                    total_income_year:
                                      anyOf:
                                        - description: >-
                                            The income year ("YYYY-YY", e.g.
                                            "2023-24") that `total_income_aud` and
                                            `revenue_range` are from: the entity's
                                            newest ATO corporate tax transparency
                                            report. Served however old — the ATO
                                            lists only entities above its income
                                            threshold, so an entity missing from
                                            later reports may have fallen below it,
                                            stopped trading or restructured; judge
                                            the figure's age from this year. Null
                                            exactly when `total_income_aud` is null.
                                          type: string
                                        - type: 'null'
                                    rdti:
                                      anyOf:
                                        - description: >-
                                            R&D Tax Incentive data (ATO
                                            data.gov.au). null when the ABN has not
                                            claimed RDTI in any published year.
                                          type: object
                                          required:
                                            - latest_year
                                            - latest_expenditure_aud
                                          properties:
                                            latest_year:
                                              anyOf:
                                                - description: >-
                                                    Most recent income year claimed (e.g.
                                                    "2022-23").
                                                  type: string
                                                - type: 'null'
                                            latest_expenditure_aud:
                                              anyOf:
                                                - description: >-
                                                    R&D expenditure (AUD) for latest_year.
                                                    Total notional deductions less feedstock
                                                    adjustments.
                                                  type: integer
                                                - type: 'null'
                                        - type: 'null'
                                    ndis:
                                      anyOf:
                                        - description: >-
                                            NDIS Provider Register data. null when
                                            the ABN is not in the register.
                                          type: object
                                          required:
                                            - provider_id
                                            - status
                                          properties:
                                            provider_id:
                                              description: NDIS Commission listing identifier.
                                              type: string
                                            status:
                                              description: >-
                                                Registration status as published on the
                                                NDIS Provider Register (e.g.
                                                'Registered', 'Revoked', 'Surrender',
                                                'Suspended').
                                              type: string
                                        - type: 'null'
                                    match:
                                      description: >-
                                        How the ABN was attached to this
                                        website, and how much to trust that
                                        link.
                                      type: object
                                      required:
                                        - confidence
                                        - level
                                      properties:
                                        confidence:
                                          anyOf:
                                            - minimum: 0
                                              maximum: 1
                                              description: >-
                                                The measured precision of the evidence
                                                pattern that linked this ABN to the
                                                website: the share of a labelled sample
                                                of websites with the same pattern whose
                                                ABN was the operating entity. A property
                                                of the pattern, not a per-row
                                                probability. Filter on it with
                                                `min_abn_confidence`.
                                              type: number
                                            - type: 'null'
                                        level:
                                          anyOf:
                                            - description: >-
                                                How much to trust the ABN link, in plain
                                                words — derived from `confidence`, the
                                                measured share of a labelled sample of
                                                websites linked the same way whose ABN
                                                was the operating entity: 'high' (at
                                                least 9 in 10 were), 'medium' (at least
                                                3 in 4) or 'low' (right between half and
                                                three times in four — confirm the legal
                                                name before relying on it). No ABN is
                                                served on a link right less than half
                                                the time. Null when `confidence` is
                                                null. Filter on it with `min_abn_level`.
                                              anyOf:
                                                - type: string
                                                  enum:
                                                    - high
                                                - type: string
                                                  enum:
                                                    - medium
                                                - type: string
                                                  enum:
                                                    - low
                                            - type: 'null'
                                - type: 'null'
                            website:
                              anyOf:
                                - description: >-
                                    Primary company website: `https://` plus the
                                    site's host, with no path (e.g.
                                    https://www.example.com.au). When the site
                                    redirects to another domain, that
                                    destination is used only if it carries the
                                    same brand name; otherwise the original host
                                    is served.
                                  type: string
                                - type: 'null'
                            domain:
                              anyOf:
                                - description: >-
                                    Canonical primary domain — bare registrable
                                    for single-tenant brands, the host for
                                    multi-tenant ones.
                                  type: string
                                - type: 'null'
                            description:
                              anyOf:
                                - description: >-
                                    How the company describes itself. Its
                                    LinkedIn About text when it has one,
                                    otherwise the best paragraph its own website
                                    offers (an about page, the schema.org
                                    description, the social preview text). When
                                    the LinkedIn About is only LinkedIn's
                                    generic auto-generated line ("X is a …
                                    company based out of <address>."), the
                                    website's text is preferred and that line is
                                    served only when the website offers nothing
                                    usable. Always text from the company's
                                    LinkedIn page or its own website, never our
                                    summary of the company. See
                                    signals.sources.description (admin) for
                                    which one.
                                  type: string
                                - type: 'null'
                            tagline:
                              anyOf:
                                - description: >-
                                    The company's short self-description or
                                    slogan — the one-line strapline from its
                                    LinkedIn page, else its website's schema.org
                                    slogan. Null when it publishes none (a page
                                    title is never used).
                                  type: string
                                - type: 'null'
                            logo:
                              anyOf:
                                - description: >-
                                    Company logo image URL — the LinkedIn page
                                    logo, else the website's schema.org logo,
                                    its social preview image, its declared
                                    apple-touch-icon, or its declared favicon
                                    (the site's own `<link rel="icon">`, which
                                    may be a small 16–32px image). Null when
                                    none of these is published. See
                                    signals.sources.logo (admin) for which one
                                    was used.
                                  type: string
                                - type: 'null'
                            linkedin:
                              anyOf:
                                - description: >-
                                    The LinkedIn organisation this record is
                                    identified by (ADR-0014: LinkedIn is the
                                    identity source; the ABN is an attribute),
                                    the two counts its page publishes, the
                                    ownership type it declares there, and the
                                    two lists of other pages it shows
                                    (`affiliated`, `similar`). Null when the
                                    record has no LinkedIn link.
                                  type: object
                                  required:
                                    - id
                                    - slug
                                    - url
                                    - members
                                    - followers
                                    - ownership_type
                                    - affiliated
                                    - affiliated_total
                                    - similar
                                  properties:
                                    id:
                                      anyOf:
                                        - description: >-
                                            LinkedIn's stable numeric organisation
                                            id (the `urn:li:organization:<id>` on
                                            the page). Survives a vanity-slug
                                            rename, so use it to detect one; it is
                                            never the DataDingo key. Null when the
                                            page was captured before the id was
                                            projected.
                                          type: string
                                        - type: 'null'
                                    slug:
                                      description: >-
                                        The organisation's LinkedIn vanity slug
                                        (the path segment after /company/).
                                      type: string
                                    url:
                                      description: >-
                                        Canonical LinkedIn organisation page
                                        URL.
                                      type: string
                                    members:
                                      anyOf:
                                        - description: >-
                                            How many LinkedIn members list this
                                            company as their employer. NOT A
                                            HEADCOUNT and never a substitute for
                                            one: measured against WGEA-reported
                                            staff numbers it is a median 4.8% of the
                                            real figure, and lands within 2x of it
                                            for only 18% of companies. Useful as a
                                            rough measure of LinkedIn presence, not
                                            of size — use `employee_range` for size.
                                            Null when the page shows no count.
                                          type: integer
                                        - type: 'null'
                                    followers:
                                      anyOf:
                                        - description: >-
                                            How many LinkedIn accounts follow the
                                            company's page — an audience-reach
                                            signal, not a size or headcount signal.
                                            Null when the follower count was not
                                            captured.
                                          type: integer
                                        - type: 'null'
                                    ownership_type:
                                      anyOf:
                                        - description: >-
                                            How the company describes its own
                                            ownership on its LinkedIn page, verbatim
                                            (e.g. 'Privately Held', 'Public
                                            Company', 'Nonprofit', 'Government
                                            Agency', 'Partnership'). Self-declared,
                                            not a register fact — for the registry
                                            view use `legal_entity.entity_type`.
                                            Null when it declares none.
                                          type: string
                                        - type: 'null'
                                    affiliated:
                                      description: >-
                                        The "Affiliated pages" the company lists
                                        on its own LinkedIn page: its parent and
                                        subsidiaries, as declared by the
                                        company's own page admins. At most 10:
                                        pages that are DataDingo records
                                        (non-empty `company_ids`) first, then
                                        the rest, each group in the order
                                        LinkedIn shows them — `affiliated_total`
                                        says how many the page lists. Empty when
                                        the page lists none.
                                      type: array
                                      items:
                                        additionalProperties: false
                                        type: object
                                        required:
                                          - slug
                                          - url
                                          - name
                                          - company_ids
                                        properties:
                                          slug:
                                            description: >-
                                              The listed page's LinkedIn vanity slug
                                              (the path segment after /company/).
                                            type: string
                                          url:
                                            description: >-
                                              The listed page's canonical LinkedIn
                                              URL, built from `slug`.
                                            type: string
                                          name:
                                            anyOf:
                                              - description: >-
                                                  The listed page's name as its LinkedIn
                                                  page gives it. Null when we hold no copy
                                                  of that page.
                                                type: string
                                              - type: 'null'
                                          company_ids:
                                            description: >-
                                              The DataDingo record ids (`id`) whose
                                              LinkedIn page is this one — look any of
                                              them up directly. A list, never a single
                                              id: records are keyed by website, so one
                                              LinkedIn page can be the page of more
                                              than one record (e.g. a company's .com
                                              and .com.au sites). Empty when the page
                                              is not one of our records.
                                            type: array
                                            items:
                                              type: string
                                    affiliated_total:
                                      description: >-
                                        How many affiliated pages the company's
                                        LinkedIn page lists. Larger than the
                                        length of `affiliated` when the list was
                                        cut; 0 when it lists none.
                                      type: integer
                                    similar:
                                      description: >-
                                        The "Similar pages" LinkedIn suggests
                                        alongside the company's page —
                                        LinkedIn's own suggestion of comparable
                                        organisations, not a relationship the
                                        company declared or that DataDingo
                                        verified. At most 10, in the order
                                        LinkedIn shows them. Useful for finding
                                        companies like this one. Empty when
                                        LinkedIn suggests none.
                                      type: array
                                      items:
                                        additionalProperties: false
                                        type: object
                                        required:
                                          - slug
                                          - url
                                          - name
                                          - company_ids
                                        properties:
                                          slug:
                                            description: >-
                                              The listed page's LinkedIn vanity slug
                                              (the path segment after /company/).
                                            type: string
                                          url:
                                            description: >-
                                              The listed page's canonical LinkedIn
                                              URL, built from `slug`.
                                            type: string
                                          name:
                                            anyOf:
                                              - description: >-
                                                  The listed page's name as its LinkedIn
                                                  page gives it. Null when we hold no copy
                                                  of that page.
                                                type: string
                                              - type: 'null'
                                          company_ids:
                                            description: >-
                                              The DataDingo record ids (`id`) whose
                                              LinkedIn page is this one — look any of
                                              them up directly. A list, never a single
                                              id: records are keyed by website, so one
                                              LinkedIn page can be the page of more
                                              than one record (e.g. a company's .com
                                              and .com.au sites). Empty when the page
                                              is not one of our records.
                                            type: array
                                            items:
                                              type: string
                                - type: 'null'
                            year_founded:
                              anyOf:
                                - description: >-
                                    The year the company says it was founded —
                                    self-declared on its LinkedIn page, else
                                    stated on its own website. This is the
                                    business's own story of its origin, which is
                                    often EARLIER than the year its current
                                    legal entity was registered; for that, use
                                    `legal_entity.year_registered`. Null when
                                    the company states no founding year.
                                  type: integer
                                - type: 'null'
                            hq_location:
                              anyOf:
                                - description: >-
                                    Headquarters city/suburb as a single string
                                    (e.g. 'Sydney'). Null when no locality is
                                    known — never a state code in its place, and
                                    never taken from the ABN's registered
                                    address. When the only address known is a
                                    LinkedIn office that publishes only a
                                    postcode, this is that postcode's
                                    representative suburb — one locality chosen
                                    per postcode, which may not be the suburb
                                    the office is actually in (postcode 2170
                                    always reads 'Liverpool'). Not an object:
                                    the head-office state is the first entry of
                                    `states` (and on its office in
                                    `locations[]`) and is what the `hq_state`
                                    search filter reads; use `locations[]` for
                                    the full office list.
                                  type: string
                                - type: 'null'
                            hq_country:
                              description: >-
                                Head-office country as its English name (e.g.
                                'Australia', 'United States'), or null when
                                unknown. Taken from the company's LinkedIn page
                                when it names a country; otherwise 'Australia'
                                when the company is listed as
                                Australian-headquartered or its head-office
                                address is Australian.
                              anyOf:
                                - type: string
                                - type: 'null'
                            web_status:
                              anyOf:
                                - description: >-
                                    What the last visit to the website found:
                                    'live' (fetched successfully within ~180
                                    days), 'stale' (fetched successfully, but
                                    longer ago than that), 'unverified' (never
                                    visited), 'blocked' (the site answered and
                                    refused us — a firewall, login wall or rate
                                    limit; the site is up), 'empty' (the visit
                                    succeeded but there was no site — a parking
                                    or for-sale lander, a suspended-hosting
                                    placeholder, a 404/410, or a page with no
                                    readable content), or 'unreachable' (the
                                    visit failed outright — DNS, connection, TLS
                                    or timeout). Independent of
                                    `legal_entity.abn_status`, which is company
                                    liveness. Null only on a record built before
                                    this field existed.
                                  type: string
                                - type: 'null'
                            web_last_verified_at:
                              anyOf:
                                - description: >-
                                    ISO 8601 timestamp of the last time the
                                    website was successfully reached. A failed
                                    re-check does not move it. Null if the site
                                    has never been fetched successfully.
                                  type: string
                                - type: 'null'
                            locations:
                              description: >-
                                The company's Australian offices, primary first.
                                Taken from the office list on its LinkedIn page
                                when it publishes one (an office's state is read
                                from its postcode when the page names no
                                region); otherwise a single entry built from the
                                headquarters fields, so a company we know a
                                location for is never served an empty list. When
                                the page lists offices but none is in the head
                                office's state, the head office is appended LAST
                                as a non-primary entry, so the state the
                                `hq_state` filter matches is always on the card.
                                At most 10 offices: the primary office and the
                                next ones in LinkedIn's order (when the cut
                                would drop every office in the head office's
                                state, the first such office takes the last
                                place) — `locations_total` says how many there
                                are, and the `state` and `locality` search
                                filters match every office, including those past
                                the cut. Empty when we know no Australian
                                location at all.
                              type: array
                              items:
                                description: One Australian office of the company.
                                type: object
                                required:
                                  - locality
                                  - state
                                  - postcode
                                  - country
                                  - is_primary
                                properties:
                                  locality:
                                    anyOf:
                                      - description: >-
                                          Suburb or city of the office (e.g.
                                          'Surry Hills'). Null when only the state
                                          is known. When only a postcode was
                                          published, this is the postcode's
                                          representative suburb — one locality per
                                          postcode — and may not be the office's
                                          own suburb.
                                        type: string
                                      - type: 'null'
                                  state:
                                    anyOf:
                                      - description: >-
                                          Australian state or territory code — one
                                          of NSW, VIC, QLD, SA, WA, TAS, NT, ACT.
                                          Null when the office's state could not
                                          be read.
                                        type: string
                                      - type: 'null'
                                  postcode:
                                    anyOf:
                                      - description: >-
                                          Australian postcode of the office. Null
                                          when not published.
                                        type: string
                                      - type: 'null'
                                  country:
                                    description: >-
                                      Always 'Australia' — non-Australian
                                      offices are not served.
                                    type: string
                                  is_primary:
                                    description: >-
                                      True for the office the company itself
                                      marks as primary on its LinkedIn office
                                      list (at most one; none when the list
                                      carries no such mark). The single entry
                                      built from the headquarters fields is
                                      always primary. A head-office entry
                                      appended AFTER a published list (see
                                      `locations`) is never primary.
                                    type: boolean
                            states:
                              description: >-
                                Every Australian state or territory the company
                                has an office in, head office first — exactly
                                what the `state` search filter matches
                                (including offices past the ten `locations[]`
                                serves). One entry for most companies; `[]` when
                                no office state is known.
                              type: array
                              items:
                                type: string
                            locations_total:
                              description: >-
                                How many Australian offices the company has on
                                record. Larger than the length of `locations`
                                when the list was cut; 0 when `locations` is
                                empty.
                              type: integer
                            employee_range:
                              anyOf:
                                - description: >-
                                    Employee-size band: the 'Company size'
                                    bucket the company publishes on its LinkedIn
                                    page — one of '1', '2-10', '11-50',
                                    '51-200', '201-500', '501-1000',
                                    '1001-5000', '5001-10000', '10001+',
                                    LinkedIn's nine bands, the vocabulary B2B
                                    tools share. It is the company's own,
                                    approximate figure: measured against
                                    register staff counts it holds the real
                                    headcount about 2 times in 3 and is within
                                    about one band nearly 9 times in 10, so say
                                    "about" and treat a neighbouring band as
                                    plausible. Null means the company publishes
                                    no size bucket we could read — not that it
                                    is small. Government register headcounts are
                                    never used here: they count the legal entity
                                    behind the ABN, which for a brand site,
                                    franchise or group often is not the
                                    organisation the website belongs to.
                                  anyOf:
                                    - type: string
                                      enum:
                                        - '1'
                                    - type: string
                                      enum:
                                        - 2-10
                                    - type: string
                                      enum:
                                        - 11-50
                                    - type: string
                                      enum:
                                        - 51-200
                                    - type: string
                                      enum:
                                        - 201-500
                                    - type: string
                                      enum:
                                        - 501-1000
                                    - type: string
                                      enum:
                                        - 1001-5000
                                    - type: string
                                      enum:
                                        - 5001-10000
                                    - type: string
                                      enum:
                                        - 10001+
                                - type: 'null'
                            employee_range_source:
                              anyOf:
                                - description: >-
                                    Where `employee_range` came from.
                                    'linkedin-banded' = the 'Company size'
                                    bucket the company itself publishes on its
                                    LinkedIn page — today the only source. Null
                                    in exactly the case `employee_range` is
                                    null.
                                  type: string
                                - type: 'null'
                            specialties:
                              description: >-
                                The capability keywords the company lists on its
                                own LinkedIn page (e.g. 'Cloud Migration',
                                'Payroll'). Self-declared marketing language,
                                not a classification — for the taxonomy view use
                                `industry`. At most 10, the first ones in the
                                company's own order — `specialties_total` says
                                how many it lists, and search (`q`) and
                                `lookup_by_name` match every one of them,
                                including those past the cut. Empty array when
                                it lists none.
                              default: []
                              type: array
                              items:
                                type: string
                            specialties_total:
                              description: >-
                                How many specialties the company's LinkedIn page
                                lists. Larger than the length of `specialties`
                                when the list was cut; 0 when it lists none.
                              type: integer
                            phones:
                              description: >-
                                Phone numbers the company publishes on its own
                                site, most-likely-switchboard first and capped.
                                Each entry carries the page it came from.
                              type: array
                              items:
                                type: object
                                required:
                                  - value
                                  - type
                                  - page_type
                                properties:
                                  value:
                                    description: >-
                                      The number in E.164 form (e.g.
                                      '+611300936385').
                                    type: string
                                  type:
                                    description: >-
                                      Number class. `tollfree` covers
                                      1300/1800/13xxxx.
                                    anyOf:
                                      - type: string
                                        enum:
                                          - tollfree
                                      - type: string
                                        enum:
                                          - landline
                                      - type: string
                                        enum:
                                          - mobile
                                      - type: string
                                        enum:
                                          - unknown
                                  page_type:
                                    description: >-
                                      The kind of page the number was published
                                      on ('contact', 'homepage', 'about', …),
                                      'unknown' when the page was recorded but
                                      its kind could not be classified, or
                                      'none' when no page was recorded.
                                    type: string
                            emails:
                              description: >-
                                Email addresses the company publishes on its own
                                site, general mailbox first and capped.
                                Off-domain mailboxes are dropped whenever an
                                on-domain one exists.
                              type: array
                              items:
                                type: object
                                required:
                                  - value
                                  - page_type
                                  - on_registrable
                                properties:
                                  value:
                                    description: The address, lower-cased.
                                    type: string
                                  page_type:
                                    description: >-
                                      The kind of page the address was published
                                      on ('contact', 'homepage', 'about', …),
                                      'unknown' when the page was recorded but
                                      its kind could not be classified, or
                                      'none' when no page was recorded.
                                    type: string
                                  on_registrable:
                                    description: >-
                                      True when the mailbox is on the company's
                                      own domain. False only when it publishes
                                      no mailbox on its own domain at all (e.g.
                                      a sole trader using freemail).
                                    type: boolean
                            social_media:
                              description: Social media profile URLs
                              type: object
                              required:
                                - x
                                - youtube
                                - facebook
                                - linkedin
                                - instagram
                                - github
                                - tiktok
                                - pinterest
                              properties:
                                x:
                                  anyOf:
                                    - type: string
                                    - type: 'null'
                                youtube:
                                  anyOf:
                                    - type: string
                                    - type: 'null'
                                facebook:
                                  anyOf:
                                    - type: string
                                    - type: 'null'
                                linkedin:
                                  anyOf:
                                    - type: string
                                    - type: 'null'
                                instagram:
                                  anyOf:
                                    - type: string
                                    - type: 'null'
                                github:
                                  anyOf:
                                    - type: string
                                    - type: 'null'
                                tiktok:
                                  anyOf:
                                    - type: string
                                    - type: 'null'
                                pinterest:
                                  anyOf:
                                    - type: string
                                    - type: 'null'
                            industry:
                              description: >-
                                Industry codes across three taxonomies (LinkedIn
                                V2, NAICS, ANZSIC), each with provenance
                                (`source`) and a `confidence`. `linkedin` is the
                                company's LinkedIn industry; `naics` is looked
                                up forwards from it (never the reverse), so it
                                is null when there is no LinkedIn industry.
                                `anzsic` is a separate judgement read directly
                                from the company's website or LinkedIn page, so
                                it can disagree with `linkedin` and `naics`, and
                                can be present when they are null (or the
                                reverse). `confidence` on `linkedin`/`naics` is
                                a trust tier; on `anzsic` it is a measured share
                                of right answers. `linkedin.alternatives`
                                carries the classifier's runner-up guesses. The
                                entity's own registry identifiers (ABN, ACN)
                                live in the `legal_entity` block.
                              type: object
                              required:
                                - linkedin
                                - naics
                                - anzsic
                              properties:
                                linkedin:
                                  anyOf:
                                    - description: >-
                                        LinkedIn V2 industry (classifier output,
                                        brand-specific)
                                      type: object
                                      required:
                                        - id
                                        - label
                                        - source
                                        - confidence
                                        - alternatives
                                      properties:
                                        id:
                                          description: LinkedIn V2 numeric industry id
                                          type: integer
                                        label:
                                          description: LinkedIn V2 industry label
                                          type: string
                                        source:
                                          description: >-
                                            How this code was determined:
                                            'classifier' (a model read the brand's
                                            website), 'self-declared' (the entity
                                            declared it itself — its LinkedIn page's
                                            industry, or its own schema.org markup),
                                            'self-declared-derived' (a NAICS code we
                                            looked up from a self-declared LinkedIn
                                            industry; the industry is the entity's
                                            own, the code is our crosswalk's). Trust
                                            runs self-declared >
                                            self-declared-derived > classifier; see
                                            `confidence`. 'self-declared-derived'
                                            appears only on `naics`, and NAICS is
                                            never a declared code — it is always
                                            looked up from the served LinkedIn
                                            industry.
                                          anyOf:
                                            - type: string
                                              enum:
                                                - classifier
                                            - type: string
                                              enum:
                                                - self-declared
                                            - type: string
                                              enum:
                                                - self-declared-derived
                                        confidence:
                                          anyOf:
                                            - description: >-
                                                Monotonic trust tier in [0,1] — NOT a
                                                calibrated probability.
                                                self-declared=0.9,
                                                self-declared-derived=0.8,
                                                classifier=0.70. Threshold on it: higher
                                                = more trustworthy provenance.
                                                (`anzsic.confidence` means something
                                                else: a measured share of right
                                                answers.)
                                              type: number
                                            - type: 'null'
                                        alternatives:
                                          description: >-
                                            The classifier's ranked runner-up
                                            industries (its 2nd/3rd guesses),
                                            most-likely first, headline excluded.
                                            Ranked, not scored — order is the
                                            signal. Empty for a
                                            government/self-derived industry or a
                                            single-guess classification.
                                          type: array
                                          items:
                                            type: object
                                            required:
                                              - id
                                              - label
                                            properties:
                                              id:
                                                description: LinkedIn V2 numeric industry id
                                                type: integer
                                              label:
                                                description: LinkedIn V2 industry label
                                                type: string
                                    - type: 'null'
                                naics:
                                  anyOf:
                                    - description: >-
                                        NAICS 2017 industry code: the official
                                        crosswalk code of the served LinkedIn
                                        industry (`industry.linkedin`). Null
                                        when there is no LinkedIn industry or
                                        the label has no NAICS crosswalk.
                                      type: object
                                      required:
                                        - code
                                        - label
                                        - source
                                        - confidence
                                      properties:
                                        code:
                                          description: NAICS 2017 code (2–6 digit)
                                          type: string
                                        label:
                                          anyOf:
                                            - type: string
                                            - type: 'null'
                                        source:
                                          description: >-
                                            How this code was determined:
                                            'classifier' (a model read the brand's
                                            website), 'self-declared' (the entity
                                            declared it itself — its LinkedIn page's
                                            industry, or its own schema.org markup),
                                            'self-declared-derived' (a NAICS code we
                                            looked up from a self-declared LinkedIn
                                            industry; the industry is the entity's
                                            own, the code is our crosswalk's). Trust
                                            runs self-declared >
                                            self-declared-derived > classifier; see
                                            `confidence`. 'self-declared-derived'
                                            appears only on `naics`, and NAICS is
                                            never a declared code — it is always
                                            looked up from the served LinkedIn
                                            industry.
                                          anyOf:
                                            - type: string
                                              enum:
                                                - classifier
                                            - type: string
                                              enum:
                                                - self-declared
                                            - type: string
                                              enum:
                                                - self-declared-derived
                                        confidence:
                                          anyOf:
                                            - description: >-
                                                Trust tier, as on `linkedin.confidence`
                                                — NOT a calibrated probability.
                                              type: number
                                            - type: 'null'
                                    - type: 'null'
                                anzsic:
                                  anyOf:
                                    - description: >-
                                        ANZSIC 2006 industry classification: a
                                        model's own judgement of the company's
                                        main activity, read from its website
                                        (else its LinkedIn page). Independent of
                                        `industry.linkedin` — the two (and
                                        NAICS) can disagree. Null when there is
                                        neither readable website text nor usable
                                        LinkedIn page text, or the company has
                                        not been classified yet; never filled in
                                        from the LinkedIn industry.
                                      type: object
                                      required:
                                        - level
                                        - code
                                        - division
                                        - label
                                        - source
                                        - confidence
                                      properties:
                                        level:
                                          description: >-
                                            How precise `code` is. Today almost
                                            always 'class' (one 4-digit class): the
                                            model names the single most likely
                                            class. 'group' (3 digits), 'subdivision'
                                            (2) and 'division' (code null — read
                                            `division`) are coarser codes the
                                            contract allows.
                                          anyOf:
                                            - type: string
                                              enum:
                                                - class
                                            - type: string
                                              enum:
                                                - group
                                            - type: string
                                              enum:
                                                - subdivision
                                            - type: string
                                              enum:
                                                - division
                                        code:
                                          anyOf:
                                            - description: >-
                                                ANZSIC 2006 code at `level`: 4 digits
                                                (class, e.g. 3242), 3 (group, e.g. 324)
                                                or 2 (subdivision, e.g. 32). Every code
                                                is a real node of the official ANZSIC
                                                hierarchy. Null when `level` is
                                                'division'.
                                              type: string
                                            - type: 'null'
                                        division:
                                          description: ANZSIC 2006 division letter (A–S)
                                          type: string
                                        label:
                                          description: >-
                                            Official ABS title of `code` (or of the
                                            division when `code` is null).
                                          type: string
                                        source:
                                          description: >-
                                            What the model read to pick the code:
                                            'website' (the company's own website
                                            text) or 'linkedin-page' (its LinkedIn
                                            page's own text — name, About and
                                            specialties — used only when there is no
                                            readable website).
                                          anyOf:
                                            - type: string
                                              enum:
                                                - website
                                            - type: string
                                              enum:
                                                - linkedin-page
                                        confidence:
                                          description: >-
                                            The measured share of right answers for
                                            this `source` on a hand-checked answer
                                            key (exact class): 'website' ≈ 0.94,
                                            'linkedin-page' ≈ 0.85 (measured on
                                            companies that have a website, reading
                                            only their LinkedIn text). A real share
                                            of right answers, unlike the trust tiers
                                            on `linkedin`/`naics`.
                                          type: number
                                    - type: 'null'
                            signals:
                              type: object
                              required:
                                - technologies
                                - email
                                - web_reach
                                - ai
                                - news
                                - careers
                                - certifications
                              properties:
                                technologies:
                                  description: >-
                                    Technologies the company uses, detected on
                                    its website ('page') or proven by its DNS
                                    records ('dns'). One entry per vendor per
                                    category, ordered by category then name.
                                    Empty when nothing buyer-useful was
                                    detected. Tier-0 firmographic signal — never
                                    gated by API_CONTACT_TIER.
                                  type: array
                                  items:
                                    description: >-
                                      One technology the company uses. Ordered
                                      by category, then name. Tier-0
                                      firmographic signal — no contact data.
                                    type: object
                                    required:
                                      - name
                                      - category
                                      - source
                                    properties:
                                      name:
                                        description: >-
                                          Canonical vendor or product name, with
                                          no version (e.g. 'WordPress', 'Microsoft
                                          365', 'HubSpot').
                                        type: string
                                      category:
                                        description: >-
                                          What the technology does for the
                                          company. One of a fixed list of
                                          buyer-facing categories.
                                        anyOf:
                                          - type: string
                                            enum:
                                              - Website platform
                                          - type: string
                                            enum:
                                              - Ecommerce
                                          - type: string
                                            enum:
                                              - Analytics
                                          - type: string
                                            enum:
                                              - Advertising
                                          - type: string
                                            enum:
                                              - Forms
                                          - type: string
                                            enum:
                                              - Live chat
                                          - type: string
                                            enum:
                                              - CRM & marketing
                                          - type: string
                                            enum:
                                              - Booking
                                          - type: string
                                            enum:
                                              - Payments
                                          - type: string
                                            enum:
                                              - Reviews
                                          - type: string
                                            enum:
                                              - Email provider
                                          - type: string
                                            enum:
                                              - Email sending
                                          - type: string
                                            enum:
                                              - Hosting & CDN
                                          - type: string
                                            enum:
                                              - DNS provider
                                      source:
                                        description: >-
                                          How we know. 'page' = seen in the
                                          website's own markup. 'dns' = proven by
                                          the domain's DNS records (mail
                                          exchangers, SPF/DKIM sending
                                          authorisations, name servers, or the
                                          network hosting the site) — stronger
                                          evidence; when both see a vendor, 'dns'
                                          is served.
                                        anyOf:
                                          - type: string
                                            enum:
                                              - page
                                          - type: string
                                            enum:
                                              - dns
                                email:
                                  description: >-
                                    DNS-derived mail facts for this company's
                                    own registrable domain. Always present; an
                                    unobserved domain reads as status
                                    'unchecked' with null fields. The mailbox
                                    provider and sending platforms are entries
                                    in `technologies`. Tier-0 firmographic
                                    signal — no contact data, never gated by
                                    API_CONTACT_TIER.
                                  type: object
                                  required:
                                    - status
                                    - can_receive_email
                                    - dmarc_policy
                                  properties:
                                    status:
                                      description: >-
                                        Observation status for the company's own
                                        domain. 'confirmed' = the domain
                                        resolves and publishes a usable mail
                                        exchanger; 'not_observed' = it resolves
                                        and definitively publishes none
                                        (including an RFC 7505 null-MX "I accept
                                        no mail"); 'inconclusive' = we looked
                                        and could not tell (NXDOMAIN, timeout,
                                        servfail); 'unchecked' = we have no DNS
                                        observation for this domain.
                                      anyOf:
                                        - type: string
                                          enum:
                                            - confirmed
                                        - type: string
                                          enum:
                                            - not_observed
                                        - type: string
                                          enum:
                                            - inconclusive
                                        - type: string
                                          enum:
                                            - unchecked
                                    can_receive_email:
                                      anyOf:
                                        - description: >-
                                            Whether mail addressed to this domain
                                            has somewhere to land (confirmed → true,
                                            not_observed → false,
                                            inconclusive/unchecked → null).
                                            DNS-INFERRED, NOT LIVE-VERIFIED — we
                                            never open a port-25 connection, so
                                            `true` means "DNS says a mailbox is
                                            configured here", not "delivery was
                                            verified".
                                          type: boolean
                                        - type: 'null'
                                    dmarc_policy:
                                      anyOf:
                                        - description: >-
                                            The domain's published DMARC enforcement
                                            policy: 'none' | 'quarantine' |
                                            'reject'. Null when none is published.
                                            DMARC reporting addresses are never
                                            surfaced.
                                          type: string
                                        - type: 'null'
                                web_reach:
                                  anyOf:
                                    - description: >-
                                        How much of the web links to this
                                        company's site, compared with other
                                        Australian companies. Null when we have
                                        no web reach for the site (for example a
                                        page on a shared platform, whose links
                                        belong to the platform, not the
                                        company). A site with no links to the
                                        site found is score 0, level `none`, not
                                        null.
                                      type: object
                                      required:
                                        - score
                                        - level
                                        - trend
                                      properties:
                                        score:
                                          minimum: 0
                                          maximum: 100
                                          description: >-
                                            0–100: the share of a fixed reference
                                            group of Australian company websites
                                            that have less of the web linking to
                                            them than this site. 0 means no links to
                                            the site found.
                                          type: integer
                                        level:
                                          description: >-
                                            The score in words: `none` (no links to
                                            the site found; score 0), `low` (1–50),
                                            `medium` (51–90) or `high` (91–100).
                                          anyOf:
                                            - type: string
                                              enum:
                                                - none
                                            - type: string
                                              enum:
                                                - low
                                            - type: string
                                              enum:
                                                - medium
                                            - type: string
                                              enum:
                                                - high
                                        trend:
                                          description: >-
                                            Is this company's web reach growing?
                                            `growing`: more of the web has come to
                                            link to the site over the last ~18
                                            months, and sites growing like this are
                                            more likely to keep growing; `steady`:
                                            no clear growth. `too_small_to_measure`:
                                            the site has too few links, or too short
                                            a history, for a reliable trend. Null
                                            when there is not enough history yet to
                                            judge.
                                          anyOf:
                                            - anyOf:
                                                - type: string
                                                  enum:
                                                    - growing
                                                - type: string
                                                  enum:
                                                    - steady
                                                - type: string
                                                  enum:
                                                    - too_small_to_measure
                                            - type: 'null'
                                    - type: 'null'
                                ai:
                                  description: >-
                                    What this company's own website declares to
                                    AI systems: whether it publishes an llms.txt
                                    it wrote itself, and whether it opts out of
                                    AI training. Read from documents the site
                                    serves publicly at fixed, well-known
                                    addresses (robots.txt, llms.txt) — no live
                                    request is made to serve it. Null when we
                                    have not read this site's files, which is
                                    not the same as a site that declares
                                    nothing. Tier-0 firmographic signal — no
                                    contact data, never gated by
                                    API_CONTACT_TIER.
                                  anyOf:
                                    - additionalProperties: false
                                      description: >-
                                        What this company's own website declares
                                        to AI systems: whether it publishes an
                                        llms.txt it wrote itself, and whether it
                                        opts out of AI training. Read from
                                        documents the site serves publicly at
                                        fixed, well-known addresses (robots.txt,
                                        llms.txt) — no live request is made to
                                        serve it. Null when we have not read
                                        this site's files, which is not the same
                                        as a site that declares nothing. Tier-0
                                        firmographic signal — no contact data,
                                        never gated by API_CONTACT_TIER.
                                      type: object
                                      required:
                                        - checked_at
                                        - llms_txt
                                        - training
                                      properties:
                                        checked_at:
                                          description: >-
                                            When the site's AI-facing files were
                                            read (ISO 8601) — the time of the visit
                                            these answers come from.
                                          type: string
                                        llms_txt:
                                          description: >-
                                            Whether the site publishes an
                                            `/llms.txt` — a plain-language guide for
                                            AI systems to what the site offers.
                                            'authored': a file the company wrote
                                            itself. 'generated': a site-builder or
                                            plugin default file (the same outline is
                                            published by many unrelated sites), so
                                            it says little about the company.
                                            'none': no such file (a missing file, a
                                            placeholder web page served under that
                                            name, or a file with no headings).
                                          anyOf:
                                            - type: string
                                              enum:
                                                - authored
                                            - type: string
                                              enum:
                                                - generated
                                            - type: string
                                              enum:
                                                - none
                                        training:
                                          description: >-
                                            Whether the site declares that it opts
                                            out of AI training. 'opted_out': the
                                            site's robots.txt names an AI training
                                            bot (GPTBot, ClaudeBot, CCBot,
                                            Google-Extended, Applebot-Extended,
                                            Meta-ExternalAgent, Bytespider) and
                                            shuts it out of the whole site where its
                                            general rule would not, or carries a
                                            Cloudflare-style content signal
                                            `ai-train=no`. 'silent': the site makes
                                            no such statement — which is not the
                                            same as consent. This is what the site
                                            declares, not what any AI bot actually
                                            experiences.
                                          anyOf:
                                            - type: string
                                              enum:
                                                - opted_out
                                            - type: string
                                              enum:
                                                - silent
                                    - type: 'null'
                                news:
                                  anyOf:
                                    - description: >-
                                        Where this company publishes, and how
                                        recently. Derived at build time from the
                                        company's own news pages we already read
                                        — no live request is made to serve it.
                                        NULL for the whole block when no
                                        news/blog page was found; non-null
                                        exactly when one is known, whether or
                                        not a date is. Tier-0 firmographic
                                        signal — no contact data, never gated by
                                        API_CONTACT_TIER.
                                      type: object
                                      required:
                                        - sources
                                        - last_published_at
                                        - checked_at
                                        - events
                                        - topics
                                        - posts_last_90d
                                      properties:
                                        sources:
                                          maxItems: 3
                                          description: >-
                                            The company's own news pages we read
                                            (news, blog, press, insights — not
                                            labelled, because sites use the names
                                            loosely), at most 3, newest post first,
                                            each with its own newest post date. `[]`
                                            means a news page is known but we have
                                            not read it yet.
                                          type: array
                                          items:
                                            description: >-
                                              One of the company's news pages, with
                                              the date of its newest post.
                                            type: object
                                            required:
                                              - url
                                              - last_published_at
                                            properties:
                                              url:
                                                description: >-
                                                  A news / blog / press page on the
                                                  company's own site that we read and
                                                  found the company's posts on.
                                                type: string
                                              last_published_at:
                                                anyOf:
                                                  - description: >-
                                                      Calendar day in the requested `tz`
                                                      (default Australia/Sydney) of the newest
                                                      post we read on THIS page. NULL when
                                                      none of its posts carried a date. A
                                                      long-quiet page keeps its old date: that
                                                      is information.
                                                    type: string
                                                  - type: 'null'
                                        last_published_at:
                                          anyOf:
                                            - description: >-
                                                Calendar day in the requested `tz`
                                                (default Australia/Sydney) of the newest
                                                post we could read across all of
                                                `sources` — the warehouse stores the
                                                publication instant and this renders it
                                                in your zone, so a 09:30 AEST post reads
                                                as that morning, not the UTC day before.
                                                NULL means no date was established —
                                                read `checked_at` to tell which kind:
                                                null `checked_at` = we have not looked
                                                yet; a set `checked_at` = we looked and
                                                could not tell (no machine-readable
                                                date, or the section would not load).
                                                Never infer dormancy from a null on its
                                                own.
                                              type: string
                                            - type: 'null'
                                        checked_at:
                                          anyOf:
                                            - description: >-
                                                ISO 8601 instant we last examined the
                                                section for a publication date. NULL
                                                means the news lane has not run for this
                                                record at all — so `last_published_at:
                                                null` beside it is ignorance, not
                                                dormancy. A set value with a null
                                                `last_published_at` means we looked and
                                                could not tell.
                                              type: string
                                            - type: 'null'
                                        events:
                                          anyOf:
                                            - description: >-
                                                Dated "why now" events the company
                                                posted on its own news section in the
                                                last 365 days, newest first, at most 10.
                                                Only event types whose labelling has
                                                been measured precise enough are served.
                                                `[]` means we read the posts and found
                                                no such event in the last 365 days
                                                (including a section with no posts that
                                                recent); NULL means recent posts exist
                                                but have not been labelled yet (or none
                                                were readable) — never read NULL as
                                                "nothing happened".
                                              type: array
                                              items:
                                                description: >-
                                                  One dated event the company announced on
                                                  its own news section.
                                                type: object
                                                required:
                                                  - type
                                                  - published_at
                                                  - title
                                                  - url
                                                properties:
                                                  type:
                                                    description: >-
                                                      What happened: one of
                                                      `acquisition_merger`,
                                                      `leadership_change`, `contract_win`,
                                                      `award_recognition`.
                                                    anyOf:
                                                      - type: string
                                                        enum:
                                                          - funding
                                                      - type: string
                                                        enum:
                                                          - acquisition_merger
                                                      - type: string
                                                        enum:
                                                          - leadership_change
                                                      - type: string
                                                        enum:
                                                          - expansion
                                                      - type: string
                                                        enum:
                                                          - product_launch
                                                      - type: string
                                                        enum:
                                                          - partnership
                                                      - type: string
                                                        enum:
                                                          - contract_win
                                                      - type: string
                                                        enum:
                                                          - award_recognition
                                                      - type: string
                                                        enum:
                                                          - certification
                                                      - type: string
                                                        enum:
                                                          - restructure
                                                      - type: string
                                                        enum:
                                                          - regulatory
                                                      - type: string
                                                        enum:
                                                          - event_participation
                                                  published_at:
                                                    description: >-
                                                      Calendar day in the requested `tz`
                                                      (default Australia/Sydney) the post was
                                                      published — or, for a post the site did
                                                      not date, the day we first saw it
                                                      appear.
                                                    type: string
                                                  title:
                                                    anyOf:
                                                      - description: >-
                                                          The post's own title. A title naming a
                                                          person is served with the name redacted;
                                                          when it could not be redacted it is
                                                          NULL, never served as written.
                                                        type: string
                                                      - type: 'null'
                                                  url:
                                                    description: >-
                                                      The post itself, on the company's own
                                                      site.
                                                    type: string
                                            - type: 'null'
                                        topics:
                                          anyOf:
                                            - description: >-
                                                What the company posts about: each
                                                label's share of its labelled, dated
                                                posts over the last 12 months, largest
                                                first; shares sum to 1. NULL when fewer
                                                than 10 such posts exist (too few to
                                                call a mix) or the posts have not been
                                                labelled.
                                              type: array
                                              items:
                                                description: One slice of the company's topic mix.
                                                type: object
                                                required:
                                                  - label
                                                  - share
                                                properties:
                                                  label:
                                                    description: >-
                                                      What the posts are about (an event type
                                                      or a topic such as thought_leadership,
                                                      customer_story).
                                                    anyOf:
                                                      - type: string
                                                        enum:
                                                          - funding
                                                      - type: string
                                                        enum:
                                                          - acquisition_merger
                                                      - type: string
                                                        enum:
                                                          - leadership_change
                                                      - type: string
                                                        enum:
                                                          - expansion
                                                      - type: string
                                                        enum:
                                                          - product_launch
                                                      - type: string
                                                        enum:
                                                          - partnership
                                                      - type: string
                                                        enum:
                                                          - contract_win
                                                      - type: string
                                                        enum:
                                                          - award_recognition
                                                      - type: string
                                                        enum:
                                                          - certification
                                                      - type: string
                                                        enum:
                                                          - restructure
                                                      - type: string
                                                        enum:
                                                          - regulatory
                                                      - type: string
                                                        enum:
                                                          - event_participation
                                                      - type: string
                                                        enum:
                                                          - thought_leadership
                                                      - type: string
                                                        enum:
                                                          - customer_story
                                                      - type: string
                                                        enum:
                                                          - company_culture
                                                      - type: string
                                                        enum:
                                                          - community_csr
                                                      - type: string
                                                        enum:
                                                          - product_update
                                                      - type: string
                                                        enum:
                                                          - promotion_offer
                                                      - type: string
                                                        enum:
                                                          - other
                                                  share:
                                                    minimum: 0
                                                    maximum: 1
                                                    description: >-
                                                      Share of the labelled, dated posts in
                                                      the last 12 months carrying this label.
                                                    type: number
                                            - type: 'null'
                                        posts_last_90d:
                                          anyOf:
                                            - minimum: 0
                                              description: >-
                                                How many dated posts appeared on the
                                                section in the last 90 days, whatever
                                                they are about. NULL when we hold no
                                                posts for this section at all.
                                              type: integer
                                            - type: 'null'
                                    - type: 'null'
                                careers:
                                  anyOf:
                                    - description: >-
                                        Where this company advertises jobs.
                                        Derived at build time from links the
                                        scrape lane ALREADY banked — no live
                                        request is made to serve it. NULL when
                                        no careers page or job-board link was
                                        found — which means we found none, never
                                        that the company is not hiring. Tier-0
                                        firmographic signal — no contact data,
                                        never gated by API_CONTACT_TIER.
                                      type: object
                                      required:
                                        - url
                                        - platform
                                      properties:
                                        url:
                                          description: >-
                                            Where this company advertises jobs, as
                                            banked by the scrape lane from links on
                                            pages it already fetched. When
                                            `platform` is set this URL is OFF the
                                            company's own domain — the company's
                                            page on an external job board /
                                            applicant-tracking system, which is
                                            preferred because it is where the jobs
                                            actually are. When `platform` is null it
                                            is the careers page on the company's own
                                            website. One URL, not a list.
                                          type: string
                                        platform:
                                          anyOf:
                                            - description: >-
                                                The external job board /
                                                applicant-tracking system hosting `url`
                                                (e.g. 'seek', 'workable', 'lever'), or
                                                NULL when `url` is the company's own
                                                careers page.
                                              type: string
                                            - type: 'null'
                                    - type: 'null'
                                certifications:
                                  description: >-
                                    Certifications, accreditations and licences
                                    the company's own website claims, derived at
                                    build time from text the scrape lane already
                                    stored (no live request). Precision-first:
                                    the claim must be explicit, so the list is a
                                    floor, not a census. Empty array when none
                                    were found. Tier-0 firmographic signal —
                                    never gated by API_CONTACT_TIER.
                                  default: []
                                  type: array
                                  items:
                                    description: >-
                                      One certification, accreditation or
                                      licence the website CLAIMS about itself.
                                      The site's own claim, not a registry fact
                                      — it may disagree with the registers.
                                    type: object
                                    required:
                                      - id
                                      - label
                                      - family
                                      - evidence
                                      - code
                                      - page_url
                                      - page_type
                                    properties:
                                      id:
                                        description: >-
                                          Stable identifier from the closed
                                          certification vocabulary.
                                        anyOf:
                                          - type: string
                                            enum:
                                              - iso-9001
                                          - type: string
                                            enum:
                                              - iso-14001
                                          - type: string
                                            enum:
                                              - iso-27001
                                          - type: string
                                            enum:
                                              - iso-45001
                                          - type: string
                                            enum:
                                              - b-corp
                                          - type: string
                                            enum:
                                              - supply-nation
                                          - type: string
                                            enum:
                                              - ndis-registered
                                          - type: string
                                            enum:
                                              - rto
                                          - type: string
                                            enum:
                                              - cricos
                                          - type: string
                                            enum:
                                              - afsl
                                          - type: string
                                            enum:
                                              - acl
                                          - type: string
                                            enum:
                                              - great-place-to-work
                                          - type: string
                                            enum:
                                              - haccp
                                          - type: string
                                            enum:
                                              - climate-active
                                          - type: string
                                            enum:
                                              - soc-2
                                          - type: string
                                            enum:
                                              - pci-dss
                                          - type: string
                                            enum:
                                              - irap
                                      label:
                                        description: >-
                                          Human-readable name of the mark, e.g.
                                          the standard or licence name.
                                        type: string
                                      family:
                                        description: >-
                                          Broad grouping: quality, environmental,
                                          safety, security, social, licence or
                                          registration.
                                        anyOf:
                                          - type: string
                                            enum:
                                              - quality
                                          - type: string
                                            enum:
                                              - environmental
                                          - type: string
                                            enum:
                                              - safety
                                          - type: string
                                            enum:
                                              - security
                                          - type: string
                                            enum:
                                              - social
                                          - type: string
                                            enum:
                                              - licence
                                          - type: string
                                            enum:
                                              - registration
                                      evidence:
                                        description: >-
                                          The exact matched text from the site,
                                          whitespace-collapsed and capped at 80
                                          characters. Never surrounding context.
                                        type: string
                                      code:
                                        anyOf:
                                          - description: >-
                                              The captured identifier for code-bearing
                                              marks (a provider or licence number);
                                              null otherwise.
                                            type: string
                                          - type: 'null'
                                      page_url:
                                        anyOf:
                                          - description: >-
                                              URL of the fetched page the claim was
                                              found on; null when it came from a
                                              site-level field.
                                            type: string
                                          - type: 'null'
                                      page_type:
                                        anyOf:
                                          - description: >-
                                              Where on the site the claim sat:
                                              "footer" for a site footer, otherwise
                                              the fetched page's own kind (about,
                                              contact, legal, …). Null when the claim
                                              came from a site-level text field with
                                              no page behind it.
                                            type: string
                                          - type: 'null'
                      not_found:
                        description: >-
                          The requested ids that match no company (free), in
                          request order, each once.
                        type: array
                        items:
                          type: string
                      charged:
                        description: >-
                          Credits this call spent: the found companies your
                          account did not already have.
                        type: integer
                      already_yours:
                        description: >-
                          Found companies your account already had (free). 0
                          when no credits are metered.
                        type: integer
                  - description: >-
                      The quote for a POST /v1/companies call (dry_run): nothing
                      is charged
                    type: object
                    required:
                      - new
                      - already_yours
                      - not_found
                      - needed
                      - available
                      - fields
                    properties:
                      new:
                        description: >-
                          Found companies your account does not have yet (each
                          costs 1 credit).
                        type: integer
                      already_yours:
                        description: Found companies your account already has (free).
                        type: integer
                      not_found:
                        description: Requested ids that match no company (free).
                        type: integer
                      needed:
                        description: >-
                          Credits the real call would spend (0 for the admin
                          token, which is never charged).
                        type: integer
                      available:
                        description: >-
                          Credits the account holds now (may be fractional after
                          AI messages); null for the admin token.
                        anyOf:
                          - type: number
                          - type: 'null'
                      fields:
                        description: >-
                          The full-card fields this API returns at its current
                          contact tier (phones and emails only when contact data
                          is served).
                        type: array
                        items:
                          type: string
        '400':
          description: Standard error response
          content:
            application/json:
              schema:
                description: Standard error response
                type: object
                required:
                  - error
                  - message
                properties:
                  error:
                    description: HTTP status code
                    type: integer
                  message:
                    description: Human-readable error message
                    type: string
        '401':
          description: Standard error response
          content:
            application/json:
              schema:
                description: Standard error response
                type: object
                required:
                  - error
                  - message
                properties:
                  error:
                    description: HTTP status code
                    type: integer
                  message:
                    description: Human-readable error message
                    type: string
        '402':
          description: Not enough credits
          content:
            application/json:
              schema:
                description: Not enough credits
                type: object
                required:
                  - error
                  - message
                  - needed
                  - available
                  - buy_url
                properties:
                  error:
                    description: HTTP status code (402)
                    type: integer
                  message:
                    description: Human-readable error message
                    type: string
                  needed:
                    description: >-
                      Credits this request needs (an AI message needs 0.5); null
                      when the token has no account
                    anyOf:
                      - type: number
                      - type: 'null'
                  available:
                    description: >-
                      Credits the account holds (may be fractional after AI
                      messages); null when the token has no account
                    anyOf:
                      - type: number
                      - type: 'null'
                  buy_url:
                    description: Where to buy credits (or sign up)
                    type: string
        '403':
          description: 'The user''s plan has ended: subscribe to keep using DataDingo'
          content:
            application/json:
              schema:
                description: 'The user''s plan has ended: subscribe to keep using DataDingo'
                type: object
                required:
                  - error
                  - code
                  - message
                  - subscribe_url
                properties:
                  error:
                    description: HTTP status code (403)
                    type: integer
                  code:
                    type: string
                    enum:
                      - plan_required
                  message:
                    description: Human-readable error message, with the subscribe link
                    type: string
                  subscribe_url:
                    description: Where to subscribe to get access back
                    type: string
        '429':
          description: Rate limit exceeded, or today's free search results used up
          content:
            application/json:
              schema:
                description: Rate limit exceeded, or today's free search results used up
                type: object
                required:
                  - error
                  - message
                  - limit
                  - remaining
                  - resets_at
                properties:
                  error:
                    description: HTTP status code (429)
                    type: integer
                  message:
                    description: Human-readable error message
                    type: string
                  limit:
                    description: >-
                      The limit that was hit: requests allowed per minute, or
                      (on `POST /v1/company/search`) search results one user may
                      receive per UTC day
                    type: integer
                  remaining:
                    description: What is left of that limit (0)
                    type: integer
                  resets_at:
                    format: date-time
                    description: >-
                      ISO 8601 instant the limit resets (the next minute, or the
                      next UTC midnight for search results)
                    type: string
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.