# UK Companies House API Scraper — PSC, iXBRL Accounts, Filings (`dominvo/uk-companies-house-api-ai-scraper`) Actor

Scrape UK Companies House data via 54 modes: company profiles, PSC ownership graphs, officer networks, iXBRL-parsed accounts (FRS 102/105), filings, charges, gazette notices, and AI director briefs. Pooled API key included — first 20 rows free.

- **URL**: https://apify.com/dominvo/uk-companies-house-api-ai-scraper.md
- **Developed by:** [Domin Vo](https://apify.com/dominvo) (community)
- **Categories:** AI, Agents, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 company records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

**Pull clean, structured data from UK Companies House — without writing a single line of API code.** This Actor delivers company profiles, beneficial ownership (PSC) graphs, officer networks, parsed annual accounts, filings, mortgages, charges, and Gazette notices for any of the 5 million+ UK companies on file.

You enter a company number or a name. We handle the rest: rate limits, retries, key rotation, pagination, and parsing. Results land in your Apify dataset as **JSON, CSV, NDJSON, Excel — or LLM-ready Markdown** — ready for your spreadsheet, BI tool, or AI agent.

### What does Companies House API Scraper do?

One Actor, **54 modes**, every UK company. Pick a mode (e.g. `company_profile`, `psc_list`, `ixbrl_accounts`), feed it a CRN (`09446231` = Monzo Bank) or a company name, and get structured rows back in seconds.

Every row uses the same envelope — `sha256`, `mode`, `crn`, `transaction_id`, `filing_date`, `payload` — so a PSC node and an iXBRL accounts fact ingest the same way downstream.

Three things make this Actor different from a plain **Companies House scraper**:

1. **PSC ownership graphs, ready-made.** Beneficial ownership trees, co-directorship networks, and shared-address clusters — pre-built. No multi-call recursion to write yourself.
2. **iXBRL accounts as typed JSON.** UK statutory accounts (FRS 102, FRS 105, UK-IFRS) parsed into 59 canonical statement lines (Revenue, Operating Profit, Total Assets, Cash, …). No PDF wrangling. **No other Apify Actor ships this.**
3. **Pay only for rows you keep.** Pay-per-event pricing from $0.00005 to $0.04. The **first 20 rows of every run are free** — prototype at zero cost.

**First 20 result rows per run are free.** No credit card to start.

### Why scrape UK Companies House data?

- **KYC & onboarding** — verify a company, surface its ultimate beneficial owners, and screen for disqualified directors or insolvency history in one API call. Skip the ComplyAdvantage seat fee.
- **M&A & due diligence** — pull parsed accounts year-over-year and compare peers without opening a single PDF.
- **Compliance monitoring** — track Gazette strike-off and winding-up notices, late filings, and director changes as they happen via SSE streams.
- **Quant & risk signals** — feed PSC churn, charge frequency, and incorporation bursts into your risk model.
- **AI agents** — every row carries optional LLM-ready Markdown, so your agent cites Companies House facts with provenance.

### How to use the Companies House API Scraper

1. Click **Try for free** on the Actor page.
2. Pick a **mode** (e.g. `company_profile`, `psc_list`, `ixbrl_accounts`).
3. Enter a **CRN** (e.g. `09446231` for Monzo Bank) — or a company name. We resolve it for you.
4. Click **Start**.
5. Grab your data from the **Output** tab.

That's it. No API key to register. No rate-limit code to write. No proxies to configure.

Or call it from Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("dominvo/uk-companies-house-api-ai-scraper").call(run_input={
    "mode": "psc_list",
    "crn": "09446231",
    "maxResults": 50,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["payload"]["name"], row["payload"]["natures_of_control"])
````

### Input — picking a mode

54 modes, one Actor. Pick the mode that matches what you need:

| Goal | Mode |
|---|---|
| Company profile, status, SIC codes | `company_profile` |
| Search the register | `company_search`, `advanced_search_companies` |
| Who controls this company? (PSC) | `psc_list`, `psc_individual`, `psc_corporate_entity` |
| Directors and officers | `company_officers`, `officer_appointments` |
| Disqualified directors | `disqualified_officer_search` |
| Annual accounts (parsed iXBRL) | `ixbrl_accounts`, `accounts_section_diff` |
| Filing history | `filing_history`, `filing_document`, `filing_chunks` |
| Mortgages & charges | `charges_list`, `charge_detail` |
| Insolvency cases | `insolvency_cases` |
| Live change feeds (SSE) | `companies_stream`, `filings_stream`, `psc_stream`, `charges_stream` |
| Gazette strike-off notices | `gazette_notices` |
| Co-directorship & address graphs | `officer_network`, `address_cluster` |
| AI director risk brief | `ai_director_brief`, `ai_summary` |
| Composite risk score | `strike_off_risk_score`, `director_risk_score` |
| Bulk register dumps (millions of rows) | `bulk_company_snapshot`, `bulk_psc_snapshot`, `bulk_accounts_archive` |

Common inputs: `crn` (8-character UK company number), `name` (auto-resolved), `query` (search text), `maxResults` (cap rows per run), `outputFormat` (`json` / `csv` / `xlsx` / `ndjson` / `md`).

### Output — JSON, CSV, Excel, Markdown

Every row uses the same envelope with a mode-specific `payload`:

```json
{
  "sha256": "a3b9c2d1…",
  "mode": "company_profile",
  "crn": "09446231",
  "filing_date": null,
  "payload": {
    "company_number": "09446231",
    "company_name": "MONZO BANK LIMITED",
    "company_status": "active",
    "date_of_creation": "2015-02-24",
    "registered_office_address": {
      "address_line_1": "Broadwalk House 5 Appold Street",
      "locality": "London",
      "postal_code": "EC2A 2AG"
    },
    "sic_codes": ["64191"],
    "has_insolvency_history": false,
    "has_charges": false
  }
}
```

Switch `outputFormat` per run:

- **`json`** — Apify dataset rows (default).
- **`ndjson` / `csv` / `xlsx`** — single file streamed to the key-value store at end of run.
- **`md`** — **LLM-ready `output.md`** bundle: one `### heading` per record, ready to paste into Claude, ChatGPT, or your RAG pipeline. The only Companies House Actor that ships native Markdown output.

### Data fields extracted

| Field | Description |
|---|---|
| `sha256` | Stable record fingerprint — re-run the same input and only changed rows are charged. |
| `mode` | The mode that produced this row. |
| `crn` | 8-character UK company number. |
| `transaction_id` | PSC ID, charge ID, or filing reference (where applicable). |
| `filing_date` | Date of the underlying filing, if any. |
| `payload.company_name` | Registered company name. |
| `payload.company_status` | `active`, `dissolved`, `liquidation`, etc. |
| `payload.sic_codes` | UK SIC industry classification. |
| `payload.kind` | PSC type (individual, corporate, legal person…). |
| `payload.natures_of_control` | How a PSC controls the company. |
| `payload.score` | Composite risk score (0–100) for signal modes. |
| `payload.financial_highlights` | LLM-generated highlights for AI modes. |
| `markdown` | Optional LLM-ready Markdown rendering of the row. |

### How much does it cost to scrape Companies House?

**The first 20 rows of every run are free.** After that, you only pay for what you receive — not for compute time, retries, or rate-limit waits.

| Data shape | Example modes | Price per row |
|---|---|---|
| Bulk register row | `bulk_company_snapshot`, `bulk_accounts_archive` | $0.00005 – $0.00025 |
| Stream event | `companies_stream`, `filings_stream`, `psc_stream` | $0.0003 |
| iXBRL accounting fact | `ixbrl_accounts`, `accounts_section_diff` | $0.001 |
| Company record | `company_profile`, `company_search` | $0.002 |
| Officer record | `company_officers`, `officer_appointments` | $0.003 |
| Charges / insolvency | `charges_list`, `insolvency_cases` | $0.004 |
| PSC node | `psc_list`, `psc_individual` | $0.005 |
| Composite signal | `strike_off_risk_score`, `director_risk_score` | $0.005 |
| Filing section | `filing_history`, `filing_chunks` | $0.008 |
| Graph edge | `officer_network`, `address_cluster` | $0.01 |
| AI brief / summary | `ai_director_brief`, `ai_summary` | $0.04 |
| Incremental delta | only when a record changes between runs | $0.0003 |

**Worked examples:**

- PSC ownership for 500 companies → **$2.50** (minus the first 20 free rows).
- Parsed iXBRL accounts for 1,000 UK companies → **$1.00**.
- AI director brief for one company (~5 LLM outputs) → **$0.20**.

### PSC ownership graphs — beneficial ownership lookup

**Find the ultimate beneficial owner of any UK company in one call.** Companies House publishes the People with Significant Control (PSC) register — but stitching it into an ownership tree is brittle, multi-call work. We do it for you.

- `psc_list` — every PSC declared by a company, with control nature, percentage ranges, and notification dates.
- `psc_individual` / `psc_corporate_entity` / `psc_legal_person` — typed detail for each PSC kind.
- `officer_network` — co-directorship graph: who else sits on the same boards.
- `address_cluster` — companies sharing a registered office, useful for shell-company detection.

Drop-in for **KYC, AML screening, and ultimate beneficial owner (UBO)** workflows.

### iXBRL accounts — FRS 102 / FRS 105 / UK-IFRS

**Get UK statutory accounts as typed JSON, not PDFs.** Most UK companies file iXBRL accounts under FRS 102, FRS 105, or UK-IFRS. We parse them into 59 canonical statement lines (Revenue, Operating Profit, Total Assets, Cash, Liabilities, …) so you can compare and screen without writing an XBRL parser.

- `ixbrl_accounts` — full parsed accounts with canonical statement-line tags.
- `accounts_section_diff` — year-over-year deltas on the same line items.
- `accounts_estimates` — derived size and health metrics.
- `accounts_peer_benchmark` — same-SIC peer comparison.

This is the moat: no other Apify Actor ships iXBRL parsing for UK companies.

### Companies House streaming API

**Subscribe to real-time changes** — companies, filings, PSCs, officers, charges, insolvency — via the Companies House Server-Sent Events streams, repackaged as flat dataset rows. Useful for compliance monitoring and change-detection alerts.

- `companies_stream` — every new and updated company.
- `filings_stream` — every new filing.
- `psc_stream` — PSC additions, ceases, and changes.
- `charges_stream`, `officers_stream`, `insolvency_stream` — narrower feeds.

Pair with the `change_detected` incremental event: re-run the same input and you only pay $0.0003 per row that actually changed since last time.

### FAQ & support

**Is this scraping?** No. We use the official Companies House REST and SSE APIs with registered application keys.

**Do I need my own API key?** No. We pool registered keys in the background so you can run the Actor with zero setup. Just pick a mode and click Start.

**What is the rate limit?** None you need to think about. We pool multiple registered keys and rotate them to give you smooth throughput on bulk runs.

**Is the data fresh?** Yes — every call hits Companies House live, except the bulk modes which use the official daily snapshots (refreshed every 24 hours).

**What formats can I download?** JSON, NDJSON, CSV, Excel, and Markdown — switch via the `outputFormat` input field. Markdown bundles every row into one LLM-ready `output.md` file.

**Can I schedule recurring runs?** Yes, via the Apify Schedules tab. Pair with `change_detected` to pay only for deltas.

**Known limits.** Scanned image-only filings require OCR and are not yet supported (planned). Documents older than ~2009 have inconsistent metadata at source.

For bugs, feature requests, or a custom data pipeline, open an issue in the Apify Issues tab.

***

Built on the [Apify SDK](https://docs.apify.com/sdk/python/), Companies House REST + SSE APIs, and an iXBRL parser tuned for FRS 102/105/UK-IFRS. Runs on a 2 GB memory tier.

# Actor input Schema

## `mode` (type: `string`):

Which mode to run. See README for full catalog.

## `crn` (type: `string`):

8-character UK CRN (e.g. 09446231). You may also supply a company name or URL — the Actor will resolve it automatically.

## `crns` (type: `array`):

List of CRNs to process in one run. Supported by modes that accept multiple companies.

## `officerId` (type: `string`):

CH officer ID (used by officer\_appointments, disqualified\_officer\_natural, disqualified\_officer\_corporate).

## `query` (type: `string`):

Full-text search query (used by company\_search, officer\_search, alphabetical\_search, dissolved\_search).

## `chargeId` (type: `string`):

CH charge ID (used by charge\_detail mode).

## `pscId` (type: `string`):

CH PSC ID (used by psc\_individual, psc\_corporate\_entity, psc\_legal\_person, psc\_super\_secure modes).

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

Maximum number of rows to emit per company / query. 0 = unlimited.

## `dateFrom` (type: `string`):

Filter results to this start date (inclusive). Applicable to filing history and stream modes.

## `dateTo` (type: `string`):

Filter results to this end date (inclusive).

## `outputFormat` (type: `string`):

json = Apify dataset (default). ndjson / csv / xlsx / md = streamed to key-value store as output.ndjson / output.csv / output.xlsx / output.md. Pick `md` for an LLM-ready Markdown bundle.

## `includeMarkdown` (type: `boolean`):

When enabled, every dataset row carries a `markdown` field alongside the JSON `payload` — ready to paste straight into an LLM prompt. Turn off to keep rows lean for spreadsheet / ETL workflows.

## `proxyConfiguration` (type: `object`):

Optional proxy for orgs whose egress firewall blocks api.company-information.service.gov.uk. Default OFF — CH ToS does not require proxying.

## Actor input object example

```json
{
  "mode": "company_profile",
  "crn": "09446231",
  "maxResults": 0,
  "outputFormat": "json",
  "includeMarkdown": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `files` (type: `string`):

No description

# 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 = {
    "mode": "company_profile",
    "crn": "09446231"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dominvo/uk-companies-house-api-ai-scraper").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 = {
    "mode": "company_profile",
    "crn": "09446231",
}

# Run the Actor and wait for it to finish
run = client.actor("dominvo/uk-companies-house-api-ai-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "company_profile",
  "crn": "09446231"
}' |
apify call dominvo/uk-companies-house-api-ai-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dominvo/uk-companies-house-api-ai-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Companies House API Scraper — PSC, iXBRL Accounts, Filings",
        "description": "Scrape UK Companies House data via 54 modes: company profiles, PSC ownership graphs, officer networks, iXBRL-parsed accounts (FRS 102/105), filings, charges, gazette notices, and AI director briefs. Pooled API key included — first 20 rows free.",
        "version": "0.0",
        "x-build-id": "qts6eNcT59wgKRGTc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dominvo~uk-companies-house-api-ai-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dominvo-uk-companies-house-api-ai-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/dominvo~uk-companies-house-api-ai-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dominvo-uk-companies-house-api-ai-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/dominvo~uk-companies-house-api-ai-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dominvo-uk-companies-house-api-ai-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "company_profile",
                            "company_registers",
                            "uk_establishments",
                            "company_exemptions",
                            "company_search",
                            "advanced_search_companies",
                            "alphabetical_search",
                            "dissolved_search",
                            "officer_search",
                            "disqualified_officer_search",
                            "company_officers",
                            "officer_appointments",
                            "disqualified_officer_natural",
                            "disqualified_officer_corporate",
                            "psc_list",
                            "psc_individual",
                            "psc_corporate_entity",
                            "psc_legal_person",
                            "psc_super_secure",
                            "psc_statements",
                            "psc_exemptions",
                            "filing_history",
                            "filing_document",
                            "charges_list",
                            "charge_detail",
                            "insolvency_cases",
                            "bulk_company_snapshot",
                            "bulk_psc_snapshot",
                            "bulk_disqualified_officers",
                            "bulk_mortgages",
                            "bulk_accounts_archive",
                            "filing_chunks",
                            "accounts_peer_benchmark",
                            "disclosure_compare",
                            "ai_summary",
                            "ai_importance",
                            "signal_pack",
                            "gazette_notices",
                            "name_change_history",
                            "companies_stream",
                            "filings_stream",
                            "charges_stream",
                            "officers_stream",
                            "insolvency_stream",
                            "psc_stream",
                            "ixbrl_accounts",
                            "accounts_section_diff",
                            "accounts_estimates",
                            "ai_director_brief",
                            "officer_network",
                            "address_cluster",
                            "director_risk_score",
                            "incorporation_burst",
                            "strike_off_risk_score"
                        ],
                        "type": "string",
                        "description": "Which mode to run. See README for full catalog."
                    },
                    "crn": {
                        "title": "Company Registration Number (CRN)",
                        "type": "string",
                        "description": "8-character UK CRN (e.g. 09446231). You may also supply a company name or URL — the Actor will resolve it automatically."
                    },
                    "crns": {
                        "title": "CRNs (batch)",
                        "type": "array",
                        "description": "List of CRNs to process in one run. Supported by modes that accept multiple companies."
                    },
                    "officerId": {
                        "title": "Officer ID",
                        "type": "string",
                        "description": "CH officer ID (used by officer_appointments, disqualified_officer_natural, disqualified_officer_corporate)."
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Full-text search query (used by company_search, officer_search, alphabetical_search, dissolved_search)."
                    },
                    "chargeId": {
                        "title": "Charge ID",
                        "type": "string",
                        "description": "CH charge ID (used by charge_detail mode)."
                    },
                    "pscId": {
                        "title": "PSC ID",
                        "type": "string",
                        "description": "CH PSC ID (used by psc_individual, psc_corporate_entity, psc_legal_person, psc_super_secure modes)."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of rows to emit per company / query. 0 = unlimited.",
                        "default": 0
                    },
                    "dateFrom": {
                        "title": "Date from (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Filter results to this start date (inclusive). Applicable to filing history and stream modes."
                    },
                    "dateTo": {
                        "title": "Date to (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Filter results to this end date (inclusive)."
                    },
                    "outputFormat": {
                        "title": "Output format",
                        "enum": [
                            "json",
                            "ndjson",
                            "csv",
                            "xlsx",
                            "md"
                        ],
                        "type": "string",
                        "description": "json = Apify dataset (default). ndjson / csv / xlsx / md = streamed to key-value store as output.ndjson / output.csv / output.xlsx / output.md. Pick `md` for an LLM-ready Markdown bundle.",
                        "default": "json"
                    },
                    "includeMarkdown": {
                        "title": "Include AI-friendly Markdown (default ON)",
                        "type": "boolean",
                        "description": "When enabled, every dataset row carries a `markdown` field alongside the JSON `payload` — ready to paste straight into an LLM prompt. Turn off to keep rows lean for spreadsheet / ETL workflows.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy for orgs whose egress firewall blocks api.company-information.service.gov.uk. Default OFF — CH ToS does not require proxying.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
