# Company Registry Lookup (`luxe_tasks/company-registry-lookup`) Actor

Legal-person companies from official registers: UK Companies House (your own API key) and Norway Brønnøysund (open data). Number, name, legal form, status, address, industry codes. No officers or people data. Price: $0.002/company record + $0.005 start fee per run.

- **URL**: https://apify.com/luxe_tasks/company-registry-lookup.md
- **Developed by:** [Luxe Tasks](https://apify.com/luxe_tasks) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 company records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Company Registry Lookup

Developer: Luxe_tasks.

Look up **companies in official business registers** and get one normalized table: one row per company with the **company number,
name, legal form, status, incorporation date, registered address, industry codes** and a link to the company on the register's own site.
It reads only the documented public APIs of **UK Companies House** (with your own Companies House API key) and **Norway's
Brønnøysundregistrene** (open data, no key). Only legal-person companies are returned, and no data about people is read or stored.
France (INSEE Sirene) is planned for a later version.
It is not affiliated with or endorsed by Companies House, Brønnøysundregistrene or any other register.

### How to use it

1. Under **Registers**, keep `no-brreg` (Norway, no key) and/or add `uk-companies-house` (UK).
2. For `uk-companies-house`, paste the REST API key of your own Companies House developer application into **Your Companies House API key** and confirm that you own it (`credentialOwnershipAttestation`). We suggest a separate Companies House API key used only for this Actor, so you can see its use and revoke it on its own.
3. Search by **Company name contains**, the incorporation date range, industry codes, location and legal forms, or list **Company numbers** to look companies up directly.
4. Run it. Companies appear in the dataset (**Company records** view), one row per company; the **SOURCE_STATUS** record in the key-value store
   (**Source status** in the run's Output tab) lists each register with its status and counts.

### How it reads the source

- Companies House: `GET https://api.company-information.service.gov.uk/advanced-search/companies` (search) and `GET https://api.company-information.service.gov.uk/company/{company_number}` (company profile, for **Company numbers** and the optional **UK: read each company profile**), with HTTP Basic authentication using your key (Companies House developer docs, authorisation guide).
  Up to 1,000 companies per request (this Actor's setting, ASSUMED to be a good page size; the API accepts up to 5,000 per request, Companies House search docs).
- Brønnøysundregistrene: `GET https://data.brreg.no/enhetsregisteret/api/enheter` (search, or a list of organisation numbers). Up to 500 units per request (this Actor's setting, ASSUMED); the API allows at most 10,000 results per search (Brreg API limit: page size times page number may not exceed 10,000).
- No other endpoint is ever requested: officer, director, persons-with-significant-control and role endpoints are refused by the Actor's code.
- Only legal-person companies are kept (see **Privacy**). A company listed twice in a run is saved once.
- Every filter you set is checked again by the Actor on each company the register returns (legal forms, company numbers, active only, name contains, incorporation dates, SIC and NACE codes, UK location, Norway municipality), because a register can return a broader set than asked (Brreg's `navn` search also returns similar names). A company that does not match is withheld: it is not saved, it is counted in `filteredOutLocally` (by filter in `filteredOutLocallyBy`), and it is excluded without a per-record charge (the $0.005 per-run start fee still applies).

### Input

- `sources` (required, 1 or 2): `no-brreg` and/or `uk-companies-house`. Any other value, including the planned French register, stops the run before any request ("Invalid input"); only the $0.005 per-run start fee applies.
- `companiesHouseApiKey` (secret; required for `uk-companies-house`): your own Companies House REST API key. It is encrypted by Apify, sent only to `api.company-information.service.gov.uk`, and never logged, echoed or saved. `credentialOwnershipAttestation` must be true when a key is given.
- `companyName` (optional): name contains this text.
- `companyNumbers` (optional, up to 100, this Actor's limit): UK company numbers (8 characters, for example `01234567` or `SC123456`) and/or Norwegian organisation numbers (9 digits). Each number goes to the register it belongs to; the other filters are not applied, except the legal-form rule.
- `activeOnly` (default on): UK `company_status` active; Norway not bankrupt, not in liquidation and not under compulsory dissolution.
- `incorporatedFrom` / `incorporatedTo` (YYYY-MM-DD, optional).
- UK only: `ukSicCodes` (SIC 2007 codes), `ukLocation`, `ukCompanyTypes` (a subset of the supported types; empty = all of them), `ukIncludeProfile` (default off), `ukMaxRequestsPerFiveMinutes` (default 600, 20-600, matching the Companies House limit; set lower if your key is used elsewhere).
- Norway only: `noIndustryCodes` (NACE codes such as `62.010`), `noMunicipalityNumbers` (4-digit `kommunenummer`, Brreg API format), `noOrganisationForms` (a subset of the supported forms; empty = all of them).
- `maxResults` (default 100, 1-5,000, this Actor's limits): most companies saved per register, and at most 10,000 per run (this Actor's limit). Each saved company is charged as one company record ($0.002 per company record), plus the $0.005 start fee per run.
- `timeoutSecs` (default 60, 5-120, this Actor's limits): how long to wait for one API answer. `maxConcurrency` (fixed at 1, this Actor's setting).
- Unknown input fields are refused.

Each run has a default timeout of 1 hour (3600 seconds, this Actor's setting). With `ukIncludeProfile` on, each company costs one extra request at about 1 request per second (this Actor's limit), so profiles are read for at most 1,000 companies per run (this Actor's limit). A maximum run then makes about 1,020 requests (1,000 profiles plus about 20 search pages, this Actor's estimate), about 1,020 seconds at that pace, inside the 3600-second timeout (ASSUMED: each API answer arrives in well under 2 seconds).
If the run is about to reach its timeout, the Actor stops starting new requests: the companies a register already returned are saved and charged (`stoppedEarly` names the reason), and a register with none found is listed as `time_limit_reached`, with no company-record charge for it (the $0.005 per-run start fee still applies).

### Output

- **Company records** (dataset, `type: "record"`; the dataset holds company rows only): `source, recordId, country, registry, companyNumber, companyName, legalForm, legalFormDescription, status, statusDetail, incorporationDate, dissolutionDate, registeredAddressLine1, registeredAddressLine2, registeredAddressLocality, registeredAddressRegion, registeredAddressPostalCode, registeredAddressCountry, industryCodes, industryDescriptions, website, employees, vatRegistered, previousNames, lastAccountsDate, profileFetched, sourceUrl, sourceAttribution, sourceLicence, sourceLicenceUrl, sourceIndex, fetchedAt`. `recordId` is `GB:<company number>` or `NO:<organisation number>`. Fields a register does not publish for a company are null.
- **Source status** (key-value store record `SOURCE_STATUS`, one JSON array): one entry per register: `index, url, source, status, requests, pages, recordsListed, excludedNotLegalPerson, filteredOutLocally, filteredOutLocallyBy, recordsMatched, recordsSaved, duplicatesSkipped, recordsNotSavedBudget, profilesFetched, stoppedEarly, charged, chargedEvents, httpStatus, error, key`. `excludedNotLegalPerson` counts entries left out because their legal form is not a supported company form; they are not saved and not part of any company-record event (the $0.005 per-run start fee is charged separately). `filteredOutLocally` counts companies the register returned that did not match your filters; they are excluded without a per-record charge (the $0.005 per-run start fee still applies).
- The run's status message and its log line `Run totals` show two labelled totals: records saved and charged, and rows withheld or filtered (excluded legal forms, filtered out locally, duplicates, over `maxResults`, over the max total charge), which are excluded without a per-record charge (the $0.005 per-run start fee still applies).
- **Records per source (JSON)** record (key-value store, `records-<index>-<host>-<hash>-json`): the same company rows as JSON, one record per register that was charged, with the register's attribution and licence.
- `RUN_SUMMARY` (key-value store): counts by status, charged `company-record` events since the last start or resume, budget reached. Apify's billing is the official record.

Source statuses with no company-record charge (the $0.005 per-run start fee still applies): `no_matching_records`, `blocked`, `rate_limited`, `skipped_blocked`, `server_error`, `fetch_failed`, `invalid_response`, `unexpected_redirect`, `api_rejected_request`, `http_error`, `response_too_large`, `robots_disallowed`, `request_refused`, `budget_reached`, `time_limit_reached`, `run_cap_reached`.

### Limits

- Only Companies House (UK) and Brønnøysundregistrene (Norway) in this version; legal-person companies only.
- At most 5,000 companies per register and 10,000 per run (this Actor's limits); `maxResults` caps saved companies; one API answer may be at most 30 MB (this Actor's limit).
- Brønnøysundregistrene returns at most 10,000 results for one search (Brreg API limit); narrow the search to see others.
- No officers, directors, persons with significant control, shareholders or beneficial owners, in any version.
- No change tracking between runs in this version.
- If a run crashes or is restarted, each register's company-record events are charged at most once per run (the $0.005 per-run start fee still applies), but the dataset and the charges can differ: a restarted run can deliver some company rows without their company-record event, and if a run stops after a register was charged but before its rows were written and is not resumed, that register's companies are only in its **Records per source (JSON)** record in the key-value store.

### Pricing

**Pricing: $0.002 per company record, plus the $0.005 start fee per run. Both are pay-per-event prices in Apify Console.**

- Pay-per-event **`company-record`**: $0.002 per company record saved to the dataset, plus the $0.005 start fee per run; each company is charged at most once per run, after the register's records are saved.
- Entries left out by the legal-form rule are not saved and have no company-record event; the $0.005 start fee per run still applies.
- Registers that deliver no company (statuses above) have no company-record charge; the $0.005 per-run start fee still applies.
- A maximum total charge set on the run is respected: each company's event is reserved before it is saved, and when the budget is used up the remaining companies are not saved (`recordsNotSavedBudget`) or the register shows `budget_reached`.
- **What you pay even when no company is charged:** the $0.005 start fee per run, charged by Apify through its synthetic `apify-actor-start` event ([Apify docs](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event#synthetic-start-event)). This Actor's memory is fixed at 1 GB (1024 MB, this Actor's setting), so the start fee is charged once per run.
- There is no per-register event: you pay $0.002 per company record plus the $0.005 start fee per run. The synthetic `apify-default-dataset-item` event is not used (the Actor refuses to run if it is priced).

### Politeness and safety

- robots.txt of each API host is honoured for every request; `Crawl-delay` is respected. A robots.txt that returns 4xx (except 429) means no restrictions; a 429 is treated as a rate limit and stops the register. For Companies House, a 5xx or an unreachable robots.txt means nothing is fetched from that host.
- Brønnøysundregistrene exception (documented open API): when `data.brreg.no/robots.txt` cannot be reached (TLS or network error, or 5xx), the Actor still reads only the documented open API paths (`/enhetsregisteret/api/enheter` and the legal-form code list), never the role paths, at the same pace, and logs `robots.txt unreachable; using documented open API` once per run. A readable robots.txt that disallows those paths is always honoured.
- A register whose robots.txt disallows its API path is not requested; its **Source status** entry explains why (`preflightMessage`), it has no company record, and it is excluded without a per-record charge (the $0.005 per-run start fee still applies). If every selected register is refused this way, the run ends as failed with that explanation, and the $0.005 per-run start fee still applies.
- At most about 1 request per second per host (this Actor's limit); fixed honest User-Agent `CompanyRegistryLookupActor/0.1.0 (+https://apify.com/luxe_tasks/company-registry-lookup; honours robots.txt)`; no proxies, no evasion.
- Companies House: "You can make up to 600 requests within a five-minute period" (Companies House rate limiting guide, https://developer-specs.company-information.service.gov.uk/guides/rateLimiting). The Actor never sends more than `ukMaxRequestsPerFiveMinutes` requests in any five-minute window (default 600, the Companies House limit); with the 1-request-per-second pace above it sends at most about 300 (this Actor's limit).
- Brønnøysundregistrene publishes no request-rate limit in its API documentation (documentation searched Nov 3, 2026); the per-host pace above applies.
- A 429 waits once (the `Retry-After` time, at most 60 seconds, this Actor's setting; 60 seconds when there is none) and is retried once; a second 429 stops that register for the rest of the run, keeping the companies already found. A 401 or 403 stops the register. Server errors (5xx) and network errors are retried twice per request (after 2 and 4 seconds, this Actor's setting).
- Only the API hosts above are ever requested; private-network addresses are refused. Your Companies House key is the only credential the Actor uses; no cookies, headers or logins can be supplied.

### Acceptable use

> By running this Actor you confirm that you will use only an API key for your own Companies House developer application; that you will
> use the data lawfully and in line with each register's terms; that you will not use the Actor to get around rate limits or any other
> access restriction; and that you will not use it to profile or contact individuals.

### Sharing your results

Companies House says it "imposes no rules or requirements on how the information on the public register is used" (Companies House, public task copyright and Crown copyright). Brønnøysundregistrene data is published under the Norwegian Licence for Open Government Data (NLOD) 2.0, which asks you to attribute the licensor, refer to the licence and, where practical, link to the licence and the source.
If you publish or redistribute results, keep each row's `sourceAttribution`, `sourceLicenceUrl` and `sourceUrl`, do not use any register's logo or the Crown insignia, and do not present the data as official or as endorsed by a register. You are responsible for how you use and share the results.

### Privacy

This Actor stores company facts only. It never requests officer, director, persons-with-significant-control, shareholder, beneficial-owner or role data, and it does not save e-mail addresses, phone numbers, "care of" names or service addresses even when a register publishes them for a company.
Only legal-person companies are kept: UK partnerships, overseas entities and other non-company types, and Norwegian sole proprietorships (`ENK`) and other forms that can belong to a natural person, are left out before saving. The supported forms are listed in the **UK company types** and **Norway organisation forms** inputs.
A company's name or registered address can still contain a person's name (for example a company named after its founder); the Actor does not change register data.
Addresses are shown as the register publishes them: no geocoding, no enrichment, and no data is kept between runs.

> "Results are written only to your run's default Apify storage. The developer does not copy, view or retain them. If your results contain
> personal data, you are the controller and the developer acts only as your processor under Apify's Standard Actor Contract. Apify's retention settings apply."

### Data sources and attribution

- UK rows: `sourceAttribution` "Contains Companies House data".
- Norway rows: `sourceAttribution` "Contains data under the Norwegian licence for Open Government data (NLOD) distributed by Brønnøysundregistrene; changed (normalised) by Company Registry Lookup", `sourceLicenceUrl` https://data.norge.no/nlod/en/2.0, and `sourceUrl` linking to the company on https://data.brreg.no.
- Every row also names its `registry` and `sourceLicence`. No register logos or images are used.

### Third-party software

Runtime dependencies (apify, robots-parser, tldts) are listed in NOTICE with their licences.

### Runtime

Node 24 (`engines`, `.nvmrc`, Dockerfile `apify/actor-node:24`). Memory: fixed at 1024 MB (this Actor's setting; the work is network-bound and rate-limited to about 1 request per second per host). Tests: `npm test`; end-to-end: `sh scripts/e2e-netns.sh` (local mock APIs only).

Contact: https://apify.com/luxe_tasks · Issues tab on the actor page.

# Actor input Schema

## `sources` (type: `array`):

Which official registers to read, one per line: no-brreg (Norway, Brønnøysundregistrene, open data, no key) and/or uk-companies-house (UK Companies House, needs your own Companies House API key). France (Sirene) is planned for a later version.

## `companyName` (type: `string`):

Companies whose name contains this text (Companies House company_name_includes; Brreg navn).

## `companyNumbers` (type: `array`):

Look up these companies directly instead of searching (at most 100). UK: 8-character Companies House numbers such as 01234567 or SC123456. Norway: 9-digit organisasjonsnummer. The other filters are not applied to a direct lookup, except the legal-form rule.

## `activeOnly` (type: `boolean`):

UK: company_status active. Norway: not bankrupt, not in liquidation or compulsory dissolution.

## `incorporatedFrom` (type: `string`):

UK: date of creation; Norway: stiftelsesdato.

## `incorporatedTo` (type: `string`):

UK: date of creation; Norway: stiftelsesdato.

## `ukSicCodes` (type: `array`):

Companies House SIC 2007 codes, e.g. 62020.

## `ukLocation` (type: `string`):

Companies House location filter, e.g. a town or postcode.

## `ukCompanyTypes` (type: `array`):

Companies House company_type values to include. Empty = all supported incorporated types: ltd, plc, llp, private-unlimited, private-unlimited-nsc, private-limited-guarant-nsc, private-limited-guarant-nsc-limited-exemption, private-limited-shares-section-30-exemption, old-public-company, european-public-limited-liability-company-se, charitable-incorporated-organisation, scottish-charitable-incorporated-organisation, industrial-and-provident-society, registered-society-non-jurisdictional, royal-charter, assurance-company, protected-cell-company, investment-company-with-variable-capital, icvc-securities, icvc-warrant, icvc-umbrella, further-education-or-sixth-form-college-corporation. Partnerships, overseas entities and other types are never included.

## `noIndustryCodes` (type: `array`):

NACE codes as Brreg uses them, e.g. 62.010 or 62.

## `noMunicipalityNumbers` (type: `array`):

4-digit kommunenummer of the business address, e.g. 0301 (Oslo).

## `noOrganisationForms` (type: `array`):

Brreg organisasjonsform codes to include. Empty = all supported legal-person forms: AS, ASA, SA, SE, SPA, GFS, BA, BBL, BRL, STI, FLI, IKS, SF, KF, FKF, PK, ANNA, SÆR. Sole proprietorships (ENK) and other natural-person forms are never included.

## `ukIncludeProfile` (type: `boolean`):

One extra Companies House request per company (previous names, status detail, last accounts date), at most 1,000 per run. Slower: about 1 second per company.

## `companiesHouseApiKey` (type: `string`):

The REST API key of your own Companies House developer application. It is sent only to api.company-information.service.gov.uk. Encrypted by Apify (secret input); never logged, stored or returned by this Actor.

## `ukMaxRequestsPerFiveMinutes` (type: `integer`):

Companies House allows up to 600 requests per 5 minutes per key. Set lower if you use the same key elsewhere.

## `maxResults` (type: `integer`):

At most this many companies are saved per register (at most 10,000 per run). Each saved company is charged as one company record, plus the $0.005 start fee per run.

## `timeoutSecs` (type: `integer`):

How long to wait for one API answer.

## `maxConcurrency` (type: `integer`):

Items processed in parallel (each site still gets at most 1 request per second).

## `credentialOwnershipAttestation` (type: `boolean`):

Required with a secret: you may supply only credentials for accounts you own or are authorized to use, for APIs whose terms permit access through automation tools.

## Actor input object example

```json
{
  "sources": [
    "no-brreg"
  ],
  "companyName": "",
  "companyNumbers": [],
  "activeOnly": true,
  "incorporatedFrom": "",
  "incorporatedTo": "",
  "ukSicCodes": [],
  "ukLocation": "",
  "ukCompanyTypes": [],
  "noIndustryCodes": [],
  "noMunicipalityNumbers": [],
  "noOrganisationForms": [],
  "ukIncludeProfile": false,
  "ukMaxRequestsPerFiveMinutes": 600,
  "maxResults": 100,
  "timeoutSecs": 60,
  "maxConcurrency": 1,
  "credentialOwnershipAttestation": false
}
```

# Actor output Schema

## `records` (type: `string`):

Default dataset, 'Company records' view: one row per saved company: source, recordId, country, registry, companyNumber, companyName, legalForm, legalFormDescription, status, statusDetail, incorporationDate, dissolutionDate, registeredAddressLine1, registeredAddressLine2, registeredAddressLocality, registeredAddressRegion, registeredAddressPostalCode, registeredAddressCountry, industryCodes, industryDescriptions, website, employees, vatRegistered, previousNames, lastAccountsDate, profileFetched, sourceUrl, sourceAttribution, sourceLicence, sourceLicenceUrl, sourceIndex, fetchedAt. The dataset holds company rows only.

## `sources` (type: `string`):

SOURCE_STATUS record (default key-value store): one JSON array with one entry per input register: index, url, source, status, requests, pages, recordsListed, excludedNotLegalPerson, filteredOutLocally, filteredOutLocallyBy, recordsMatched, recordsSaved, duplicatesSkipped, recordsNotSavedBudget, profilesFetched, stoppedEarly, charged, chargedEvents, httpStatus, error, key (plus preflightFailed and preflightMessage for a register that failed its robots.txt preflight).

## `sourceFiles` (type: `string`):

Default key-value store, records starting with 'records-': one JSON record per register that was charged ({source, sourceIndex, fetchedAt, sourceAttribution, sourceLicence, sourceLicenceUrl, recordCount, records}), the same company rows as in the dataset.

## `runSummary` (type: `string`):

RUN_SUMMARY record: totals by status, charged company-record events since the last start or resume, budget reached and stopped domains.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sources": [
        "no-brreg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("luxe_tasks/company-registry-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "sources": ["no-brreg"] }

# Run the Actor and wait for it to finish
run = client.actor("luxe_tasks/company-registry-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sources": [
    "no-brreg"
  ]
}' |
apify call luxe_tasks/company-registry-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,luxe_tasks/company-registry-lookup"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/9xxiatvuCBMgSARd1/builds/zwFbidadxCeIEHH95/openapi.json