> ## 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.

# Company Enrichment

> Look up an Australian company by ID, domain, website, or LinkedIn organisation (slug, URL, or numeric id) and return the full enriched company profile including government data (ABR, ASIC, ATO), industry codes, social media, the technologies the company uses, and web traffic. A found company costs 1 credit the first time your account sees it and is free after; a lookup that finds nothing is free.



## OpenAPI

````yaml /openapi.json get /v1/company
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/company:
    get:
      tags:
        - Company
      summary: Company Enrichment
      description: >-
        Look up an Australian company by ID, domain, website, or LinkedIn
        organisation (slug, URL, or numeric id) and return the full enriched
        company profile including government data (ABR, ASIC, ATO), industry
        codes, social media, the technologies the company uses, and web traffic.
        A found company costs 1 credit the first time your account sees it and
        is free after; a lookup that finds nothing is free.
      parameters:
        - schema:
            maxLength: 100
            type: string
          in: query
          name: id
          required: false
          description: Deterministic DataDingo company ID
        - schema:
            minLength: 1
            maxLength: 255
            type: string
          in: query
          name: domain
          required: false
          description: >-
            Domain name (e.g. 'smec.com'). Resolves the bare registrable, a
            TLD-sibling, or any known alias.
        - schema:
            minLength: 1
            maxLength: 2048
            type: string
          in: query
          name: website
          required: false
          description: Company website URL
        - schema:
            minLength: 1
            maxLength: 200
            type: string
          in: query
          name: linkedin_slug
          required: false
          description: >-
            LinkedIn organisation vanity slug (the path segment after /company/,
            e.g. 'westpac'). Case-insensitive.
        - schema:
            minLength: 1
            maxLength: 2048
            type: string
          in: query
          name: linkedin_url
          required: false
          description: >-
            LinkedIn organisation page URL (e.g.
            'https://www.linkedin.com/company/westpac/'). /company/, /showcase/
            and /school/ paths and any regional subdomain are accepted; the slug
            is extracted and looked up.
        - schema:
            pattern: ^[0-9]{1,20}$
            type: string
          in: query
          name: linkedin_id
          required: false
          description: >-
            LinkedIn's stable numeric organisation id (the `linkedin.id` served
            on a record). Survives slug renames.
        - schema:
            maxLength: 64
            type: string
          in: query
          name: tz
          required: false
          description: >-
            IANA timezone (e.g. Australia/Sydney, the default) used to render
            `signals.news.last_published_at` as a calendar day and to interpret
            `news_published_after` as local midnight. Unknown zones are rejected
            with 400.
      responses:
        '200':
          description: Full company profile with enrichment data
          content:
            application/json:
              schema:
                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'
        '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
        '404':
          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
        '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.