# Australian company register lookup

> A paid HTTP API that looks up Australian companies by ABN, ACN or company name over the ASIC Company Dataset. 4,008,800 companies. One call costs USD 0.01, paid in USDC on Base under the x402 protocol. There is no account, no API key and no free tier: the payment header is the credential.

Reach for this when you need to resolve an Australian company identifier or name to its register record and you want to pay per call rather than sign up. It answers three questions: what company holds this ABN, what company holds this ACN, and which companies have a name starting with this string. It returns the company name, ACN or ARBN, ABN, registration status, entity type and class, registration and deregistration dates, the state of previous registration, and former names.

Do not reach for it when you need any of these, because it does not have them: GST registration status, business address, state or postcode, director or officeholder details, trading names, financial data, or anything about a sole trader or partnership that is not a registered company. Those fields live in the Australian Business Register extract, not in the ASIC company dataset. It is also not the official register: it is a weekly snapshot, and ASIC Connect is authoritative for anything that matters legally.

Pricing and payment: USD 0.01 per call, USDC on Base mainnet (eip155:8453), x402 protocol versions 1 and 2. A call that matches nothing returns 404 and is not charged. Requests are rate limited per caller; this is a lookup, not a bulk export, and the full dataset is free to download from data.gov.au if that is what you want.

Snapshot built at 2026-09-09T04:09:56+00:00. Contains ASIC Company Register data sourced from data.gov.au, © Australian Securities and Investments Commission, licensed under CC BY 3.0 AU.

## API

- [Landing page and worked examples](https://api.nightshiftbuilds.com/): what it is, what it costs, and a copy-paste example of the full 402 payment flow.
- [OpenAPI 3.1 description](https://api.nightshiftbuilds.com/openapi.json): every operation, parameter and response, including the 402 challenge schema. The canonical machine description.
- [Rendered API reference](https://api.nightshiftbuilds.com/docs): the same OpenAPI document, readable.
- [GET /v1/company](https://api.nightshiftbuilds.com/v1/company): the one paid endpoint. Exactly one of `abn`, `acn` or `name`.
- [GET /health](https://api.nightshiftbuilds.com/health): liveness, row count and snapshot date. Free.
- [Docs and runnable examples](https://github.com/keitaemsden-lab/asic-lookup-api-docs): Python and TypeScript clients that make a real paid call, plus the error semantics worth handling.

## Terms and provenance

- [Terms of service](https://api.nightshiftbuilds.com/terms): licence, attribution, what is logged, refunds, fair use.
- [ASIC Company Dataset](https://data.gov.au/data/dataset/asic-companies): the source dataset on data.gov.au, licensed CC BY 3.0 AU.
- [ASIC Connect](https://connectonline.asic.gov.au): the official, real-time register. Authoritative where this snapshot is not.

## Optional

- [x402 protocol](https://x402.org): the payment standard this API speaks.
- [Full text for agents](https://api.nightshiftbuilds.com/llms-full.txt): this file with the worked payment flow and the response schema inline.
- [Contact](keita.emsden@gmail.com)

---

## How to call this API, in full

### 1. Ask without paying, and read the terms

```
curl -i "https://api.nightshiftbuilds.com/v1/company?name=woolworths"
```

The response is `402 Payment Required`. Two payment documents come back, one for
each live protocol version, because neither is a superset of the other:

- The BODY is an x402 v1 challenge: `x402Version: 1`, `accepts[0].network:
  "base"`, the price in `maxAmountRequired`.
- The `PAYMENT-REQUIRED` HEADER is base64 of an x402 v2 challenge:
  `x402Version: 2`, a top-level `resource` object, `accepts[0].network:
  "eip155:8453"`, the price in `amount`, and a `bazaar` extension carrying the
  input and output schema for this endpoint.

A v1 client reads the body and never knows the header exists. A v2 client reads
the header and ignores the body. Both get a document their own schema validates.

Payment terms, verbatim:

- scheme: `exact`
- network: `eip155:8453` (Base mainnet) for v2, `base` for v1
- asset: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` (USDC on Base)
- payTo: `0xAe6606fDc5e8b63BA62863E130dEead2fAdaE31f`
- amount: `10000` atomic units, which is
  USD 0.01
- maxTimeoutSeconds: 300

### 2. Sign an authorisation and retry

The payment is an EIP-3009 `transferWithAuthorization` signed by the payer's
key. You do not need to write that yourself; the official x402 SDKs do it:

Python, using the official `x402` SDK:

```python
import asyncio, os
from eth_account import Account
from x402 import x402Client
from x402.http.clients import x402HttpxClient
from x402.mechanisms.evm.exact import ExactEvmScheme

account = Account.from_key(os.environ["PRIVATE_KEY"])
client = x402Client()
client.register("eip155:8453", ExactEvmScheme(signer=account))

async def main():
    async with x402HttpxClient(client) as http:
        r = await http.get("https://api.nightshiftbuilds.com/v1/company?name=woolworths")
        print(r.json())

asyncio.run(main())
```

TypeScript, using `@x402/fetch`:

```ts
import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
import { ExactEvmScheme } from "@x402/evm";
import { privateKeyToAccount } from "viem/accounts";

const signer = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const client = new x402Client().register("eip155:8453", new ExactEvmScheme(signer));
const fetchWithPay = wrapFetchWithPayment(fetch, client);

const res = await fetchWithPay("https://api.nightshiftbuilds.com/v1/company?name=woolworths");
console.log(await res.json());
```

### 3. What you get back

`200 OK`, with the settlement transaction hash in the `PAYMENT-RESPONSE` header:

```json
{
  "query": {
    "name": "woolworths"
  },
  "count": 1,
  "charged": true,
  "request_id": "a1b2c3d4e5f6",
  "results": [
    {
      "company_name": "WOOLWORTHS GROUP LIMITED",
      "acn": "000014675",
      "arbn": null,
      "abn": "88000014675",
      "status": "Registered",
      "status_code": "REGD",
      "entity_type": "Australian public company",
      "entity_type_code": "APUB",
      "class": "Limited by shares",
      "sub_class": "Listed public company",
      "date_of_registration": "1924-09-22",
      "date_of_deregistration": null,
      "previous_state_of_registration": "NSW",
      "state_registration_number": "00921434",
      "current_name_start_date": null,
      "former_names": [
        "WOOLWORTHS LTD"
      ]
    }
  ],
  "payment": {
    "price_usd": 0.01,
    "settlement_tx": "0x2c8ced11a0655d834166956606883cde954f61bbeb2549f95b3cc95b43bbcf8e",
    "network": "base"
  },
  "provenance": {
    "data_source": "ASIC - Company Dataset",
    "licence": "CC BY 3.0 AU",
    "attribution": "...",
    "snapshot_built_at": "...",
    "disclaimer": "..."
  }
}
```

### Failure modes worth handling

- `400` - you sent zero or more than one of `abn`, `acn`, `name`, or a
  malformed one. Checked BEFORE payment, so a bad query never costs anything.
- `402` - no payment, or an invalid or expired one. The body and header carry a
  fresh challenge.
- `404` - the query was valid and matched nothing. `charged: false`. The payment
  authorisation is released, so you can spend it on a different query.
- `409` - this payment authorisation was already used, or is in flight. Do not
  resend it. Replaying the SAME authorisation with the SAME query returns the
  original answer instead, so a lost response can be recovered without paying
  twice.
- `429` - rate limited. Honour `Retry-After`.
- `503` - the payment did not complete against the facilitator. Branch on
  `charged`, do not just retry. `charged: false` means verification failed
  before any transfer, so retrying is safe. `charged: "unknown"` means
  settlement was submitted and the outcome was never learnt, so money MAY have
  moved: do NOT sign a fresh authorisation, resend the identical request with
  the identical one and you will get the stored answer if it did settle.

### Idempotency

The payment authorisation nonce is the idempotency key. If settlement succeeded
but you lost the response, resend the identical request with the identical
authorisation and you will get the stored answer back, not a second charge. The
retrieval is bound to both the query and the payer's signature, so a nonce
someone else observed cannot be used to collect the data it bought.