# UK Companies House New Company Filings Scraper (`pradio/new-company-filings`) Actor

Scrapes new company filings from the UK Companies House register on a schedule: companies incorporated or dissolved in the last daysBack days, deduplicated so each run emits only new or status-changed rows. Company number, name, status, type, dates, registered office, SIC codes, due dates.

- **URL**: https://apify.com/pradio/new-company-filings.md
- **Developed by:** [Pradio Actors](https://apify.com/pradio) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.16 / 1,000 company returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## UK Companies House New Company Filings Scraper

### What does UK Companies House New Company Filings Scraper do?

UK Companies House New Company Filings Scraper reads the UK Companies House register and returns one row per newly incorporated or dissolved company: number, name, status, type, dates, registered office and SIC codes. It is built for a schedule. The Actor remembers what it already sent, so each run emits only companies that are new or whose register status changed. For a company you already know, paste its number into `companyNumbers` and it comes back as one detailed row. There is no login, no API key and no browser: the register's pages are server-rendered and read over plain HTTP.

On the default input (7 days back, cap of 100 rows) a live run returned 100 companies in about a minute. Every row carries the register page it was read from, and each returned row costs $0.004.

### Who uses UK Companies House New Company Filings Scraper

| Who | What they run it for |
|---|---|
| Accountants taking on new clients | A weekly feed of newly incorporated companies, with SIC codes to pick the ones that fit |
| Insurance brokers | New employers the week they register, in time to quote the compulsory cover every UK employer must carry |
| Banks and onboarding teams | A counterparty's registration date and live register status, straight from the source |
| B2B sellers to brand-new businesses | Leads from the register itself, weeks before scraped databases carry them |

### Features

- **A feed, not a snapshot.** The Actor remembers each company it emits for 31 days. A scheduled run returns only new or status-changed rows, never the same list twice.
- **Two windows per run.** Every run reads the register's advanced search twice: companies incorporated in the last `daysBack` days, and companies dissolved in them.
- **Your own filters as URLs.** Paste a Companies House advanced-search results URL into `startUrls` and the run reads that list instead, tagged `matched_filter`.
- **One company by number.** `companyNumbers` takes register numbers or company page URLs and returns one detailed row each, tagged `lookup`: a number the register does not know comes back as an uncharged `not_found` row.
- **SIC code and text filter.** `searchQueries` matches a code prefix like `43` or words in the description like `restaurant`.
- **Opt-in officers, PSC and filing reads.** `includeOfficers`, `includePsc` and `includeFilings` add one register tab read per company and fill the matching fields.
- **Dissolutions first under a cap.** When `maxItems` cuts a run short, status changes and dissolutions come back before the long incorporation list.
- **Proxy support.** `proxyConfiguration` sends every register read through your Apify proxy setup.
- **Polite, bounded reads.** One request at a time with a pause between them. A 429 or server error is retried with backoff, and a refusal stops the run.
- **The register's own URLs.** Every link a row carries points at Companies House, so each value checks back to the source page.

### What you can count on

- You pay only for rows whose `row_status` reads `ok`. A per-item miss is pushed as an uncharged `ITEM_STATUS` row, so you see the verdict and are never billed for it.
- A row is charged only after it is written to your dataset. A row you cannot see is never billed.
- A run that finds nothing returns one `PROFILE_NOT_FOUND` row that says so. You never get a silent empty dataset.
- A spending limit stops the run cleanly. One `STOPPED_EARLY` row reports how many rows were returned and how many were not.
- Every run writes a `RUN_SUMMARY` entry with rowsFetched, rowsPushed, rowsCharged and duplicatesDropped. A short run and a broken one are easy to tell apart.
- If the register changes its pages, the run fails with the error in the log. It never returns rows full of nulls and calls it success.
- No value is invented. A field the register does not show is `null`, and the always-empty ones are named below.

### What data does UK Companies House New Company Filings Scraper return?

One real row from a live run:

```json
{
  "company_number": "17452936",
  "register_page_url": "https://find-and-update.company-information.service.gov.uk/company/17452936",
  "company_name": "CPG RETENTION HOLDING LIMITED",
  "row_status": "ok",
  "event": "newly_registered",
  "registrar": "Companies House",
  "jurisdiction": "England and Wales",
  "company_status": "Active",
  "company_type": "Private Limited Company",
  "country_of_origin": "United Kingdom",
  "incorporation_date": "2026-09-11",
  "dissolution_date": null,
  "registered_office_address": {
    "AddressLine1": "2 LEMAN STREET",
    "PostTown": "LONDON",
    "Country": "UNITED KINGDOM",
    "Postcode": "E1W 9US"
  },
  "address_line_1": "2 LEMAN STREET",
  "city": "LONDON",
  "postcode": "E1W 9US",
  "country": "UNITED KINGDOM",
  "accounts_due": "2028-06-11",
  "confirmation_statement_due": "2027-09-24",
  "sic_codes": {
    "SicText": [
      "64209 - Activities of other holding companies not elsewhere classified"
    ]
  },
  "register_urls": [
    "https://find-and-update.company-information.service.gov.uk/company/17452936",
    "https://data.companieshouse.gov.uk/doc/company/17452936.json"
  ],
  "filing_history_url": "https://find-and-update.company-information.service.gov.uk/company/17452936/filing-history",
  "first_director": null,
  "officers": null,
  "persons_with_significant_control": null,
  "latest_filing": null,
  "search_metadata": {
    "query": "https://find-and-update.company-information.service.gov.uk/advanced-search/get-results?incorporationFromDay=10&incorporationFromMonth=9&incorporationFromYear=2026&incorporationToDay=17&incorporationToMonth=9&incorporationToYear=2026",
    "event": "newly_registered"
  },
  "row_type": "ROW"
}
```

Every data row carries the same full field set. The opt-in fields fill only when you turn on the matching input flag; the rest are read on every run.

| Field | What it is |
|---|---|
| `row_status` | The row's own verdict: `ok` on a data row. The register's verdict on the company lives in `company_status`. |
| `event` | Why the company is in this run: `newly_registered`, `dissolved`, `registered_and_dissolved`, `matched_filter` or `lookup` (a company you named by number). |
| `company_name` | The registered name, as the register prints it. |
| `company_number` | The Companies House company number. Rows are de-duplicated on it, inside the run and across runs. |
| `registrar` | The register the company sits on: `Companies House` on every row. |
| `jurisdiction` | Registration jurisdiction from the number prefix: England and Wales, Scotland, Northern Ireland, an overseas company or a Societas Europaea. |
| `company_status` | The register's live status, such as `Active` or `Dissolved`. |
| `company_type` | The register's company category, such as `Private Limited Company`. |
| `country_of_origin` | The register's country of origin: `United Kingdom` on the captured rows. |
| `incorporation_date` | Incorporation date as ISO `YYYY-MM-DD`. |
| `dissolution_date` | Dissolution date as ISO `YYYY-MM-DD`; `null` unless the register marks the company dissolved. |
| `registered_office_address` | The register's address object: address lines, post town, county, country and postcode. |
| `address_line_1` | First line of the registered office address. On a company at the register's default address this is the register's own `Companies House Default Address` line, verbatim. |
| `city` | The registered office post town. |
| `postcode` | The registered office postcode. |
| `country` | The registered office country line; `null` on a Companies House default address. |
| `accounts_due` | Next accounts due date, ISO. `null` on dissolved rows. |
| `confirmation_statement_due` | Next confirmation statement due date, ISO. `null` on dissolved rows. |
| `sic_codes` | The register's SIC codes object: a `SicText` list of `code - description` lines. |
| `register_page_url` | The company's overview URL on the register. The register does not publish the company's own site. |
| `register_urls` | Both register URLs for the company: the overview page and its structured data document. |
| `filing_history_url` | URL of the company's filing-history page on the register. |
| `first_director` | **Opt-in.** `null` until `includeOfficers` is on: the first officer with a director role who has not resigned. |
| `officers` | **Opt-in.** `null` until `includeOfficers` is on: every officers-tab appointment, with name, role, appointed and resigned dates and status. |
| `persons_with_significant_control` | **Opt-in.** `null` until `includePsc` is on: PSC tab entries, with name, notified-on date, natures of control and status. |
| `latest_filing` | **Opt-in.** `null` until `includeFilings` is on: the newest filing's date, type and description, never the document itself. |
| `search_metadata` | Which register read produced the row: the exact results URL, or the company page on a `lookup` row, and its event tag. |
| `row_type` | `ROW` on a data row. Status rows carry `ITEM_STATUS`, `PROFILE_NOT_FOUND` or `STOPPED_EARLY`. |

The opt-in fields `first_director`, `officers`, `persons_with_significant_control` and `latest_filing` are `null` on a default run and fill only when their flag is on, verified on live rows. `dissolution_date` is `null` on every active company by design. The Console's **Overview** tab shows the fields this source fills; **All fields** and every export carry the whole set, so the empty columns stay visible where you want them.

Status rows carry fields of their own:

| Field | What it is |
|---|---|
| `reason` | On a status row only: why no data rows came back, or why the run stopped early. |
| `rowsFetched` | On a status row only: how many rows the source handed over before de-duplication and the cap. |
| `rowsReturned` | On a status row only: how many data rows are in the dataset (0 on a zero result). |
| `rowsRemaining` | On a status row only: how many fetched rows were not returned. |

### How much does it cost?

The price is **$0.004** per company row written to your dataset, charged as one `company-returned` event per row.

| Rows in the run | Charged events | Cost |
|---|---|---|
| 100 | 100 | $0.40 |
| 1,000 | 1,000 | $4.00 |
| 10,000 | 10,000 | $40.00 |

Not charged: `PROFILE_NOT_FOUND`, `STOPPED_EARLY` and `ITEM_STATUS` status rows, duplicates dropped inside the run, and companies the feed already sent you, which are never returned. Apify also bills its standard `apify-actor-start` charge at $0.00005 per start event, one event per GB of run memory with a minimum of one; at this Actor's 512 MB default that is one event per run. This Actor adds nothing on top of it.

Because a scheduled run emits only what is new, a quiet week costs little and a week with no new filings charges nothing beyond the start.

### How do I use UK Companies House New Company Filings Scraper?

1. Open the Actor page and press **Start**. The default input needs nothing: no keys, no URLs, no setup.
2. Rows land in the dataset as they are read. Export them as JSON, CSV or Excel, or pull them through the API.
3. Put the Actor on a daily or weekly Apify schedule. The built-in memory keeps each run to what is new.

The default input needs nothing changed. It looks like this:

```json
{
  "daysBack": 7,
  "maxItems": 100,
  "includeOfficers": false,
  "includePsc": false,
  "includeFilings": false
}
```

To filter the feed to the trades you serve, add `searchQueries` and switch on any tab reads you need:

```json
{
  "daysBack": 7,
  "maxItems": 100,
  "searchQueries": ["43", "restaurant"],
  "includeOfficers": true
}
```

Or feed it a filtered results page straight from the register's advanced search:

```json
{
  "startUrls": [
    { "url": "https://find-and-update.company-information.service.gov.uk/advanced-search/get-results?incorporationFromDay=8&incorporationFromMonth=9&incorporationFromYear=2026&incorporationToDay=15&incorporationToMonth=9&incorporationToYear=2026" }
  ]
}
```

Or name the companies directly; each comes back as one detailed row:

```json
{
  "companyNumbers": ["00000006", "SC327447"]
}
```

Through the API:

```
curl -X POST "https://api.apify.com/v2/acts/Pradio~new-company-filings/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" -H "Content-Type: application/json" -d "{\"daysBack\": 7, \"maxItems\": 100}"
```

### Input

| Input | Default | What it does |
|---|---|---|
| `daysBack` | `7` | How many days back the incorporation and dissolution windows reach. |
| `maxItems` | `100` | The most company rows one run returns. |
| `startUrls` | empty | Pasted advanced-search results URLs replace the built-in windows. |
| `companyNumbers` | empty | Company numbers or company page URLs; each returns one detailed row. When this is the only input given, no window or search is read. |
| `maxItemsPerStartUrl` | none | Caps how many companies each pasted `startUrls` entry may contribute, so one long list cannot spend the whole `maxItems` budget. |
| `searchQueries` | empty | SIC code prefix or text filter applied to the returned companies. |
| `includeOfficers` | `false` | Also read each company's officers tab; fills `officers` and `first_director`. |
| `includePsc` | `false` | Also read each company's PSC tab; fills `persons_with_significant_control`. |
| `includeFilings` | `false` | Also read each company's filing history; fills `latest_filing`. |
| `proxyConfiguration` | none | Send every register read through an Apify proxy. |

#### startUrls

Only one kind of link works here: a results URL from the register's own advanced search. Set your filters on the Companies House site, copy the address bar on the results page and paste it in. Anything else fails the run fast with a message naming the refused URL. Rows from a pasted search are tagged `matched_filter` in `event`.

Each pasted URL is read as its own list. With several pasted, set `maxItemsPerStartUrl` to give every entry its own bound instead of letting the longest list spend the shared `maxItems` budget first.

#### companyNumbers

For a company you already know, give its register number, `00000006`, or paste its company page URL. Each entry comes back as one detailed row tagged `lookup` in `event`: the same fields a feed row carries, including the opt-in tabs when their flags are on. A number the register has no company under comes back as an uncharged `not_found` row with the reason. A named company is emitted every time you ask for it (the run-to-run memory only dedupes the feed), and a number that also turns up in a pasted search keeps its `lookup` tag.

#### searchQueries

Each entry is matched against the company's SIC lines. A prefix matches codes, so `43` keeps `43220 - Plumbing, heat and air-conditioning installation`. Plain text matches the description, so `restaurant` keeps `56101 - Licensed restaurants`. Companies with no SIC match are dropped before output.

#### The include flags

Each flag adds one register read per company, so all three together send four reads per company instead of one. That is why they default to off. A failed tab read leaves the matching fields `null` on that row instead of failing the run.

### Output

A run pushes data rows with `row_type: "ROW"` plus, when something needs saying, one status row. Everything lands in the default dataset.

- `ROW`: a company the run emitted. Charged after it is pushed.
- `ITEM_STATUS`: a per-item miss, pushed so you see the verdict: a company number the register does not know comes back with `row_status: "not_found"`. Never charged.
- `PROFILE_NOT_FOUND`: the register answered and nothing matched. One row, not charged, and `reason` says why.
- `STOPPED_EARLY`: your charge limit ended the run. One row, not charged, carrying `rowsReturned` and `rowsRemaining`.

A zero result is an answer, not a failure: the run pushes one `PROFILE_NOT_FOUND` row and charges nothing. On a schedule it usually means the feed already sent everything the window held.

`RUN_SUMMARY` in the default key-value store carries `rowsFetched`, `rowsPushed`, `rowsCharged` and `duplicatesDropped` for every run.

### What can you do with the data?

**An accountant** sets a Monday-morning schedule with `searchQueries` for the trades the firm serves. Every company incorporated in the last 7 days arrives with its SIC codes, registered office and incorporation date, ready for a welcome letter.

**An insurance broker** watches the same feed for new employers. A company that just registered is close to needing the compulsory cover every UK employer must carry, and the register row is the earliest reliable signal.

**An onboarding team** pastes the register's own filtered search URL as `startUrls` and gets a deduplicated list of counterparties with live status and registration dates for KYC checks.

**A data team** runs the feed daily and watches the `dissolved` and `registered_and_dissolved` rows: companies leaving the register the week it happens, not after the next database refresh.

### Use UK Companies House New Company Filings Scraper with AI agents

Paste this line to give an MCP-capable agent this Actor:

```
claude mcp add --transport http apify "https://mcp.apify.com?tools=Pradio/new-company-filings"
```

The agent can then read the input schema, start runs and pull the dataset on its own.

### Personal data

Some rows name people. `officers`, `persons_with_significant_control` and `first_director` carry a person's name in their business capacity only: role, appointment or notification dates and status. No filing documents, PDFs or statement text are ever reproduced.

- **Transparency.** Every value comes from the Companies House register, which publishes this data under statutory obligation. Each row's `register_page_url` points back to the register page it was read from.
- **Controller.** Companies House controls the register's own publication. For the rows you export you are the controller, so keep a defined purpose and honour the obligations that come with one.
- **Minimum.** Turn the officer and PSC flags on only when you need them. Each one adds named people to every row.
- **Removal.** A person named in a row can ask for deletion or correction through this Actor's Issues tab on the Apify Store, and the request is honoured. Companies House also runs its own suppression process for the register itself.
- **Terms.** Companies House's terms do not prohibit reading the register this way, but permission is not explicit either. Reads stay per company and sequential, the run stops on any refusal, and no bulk copy of the register is made.

### Release notes

- `0.1`: first public build, with the incorporation and dissolution windows, the run-to-run diff, the SIC filter, direct company-number lookup and the three opt-in tab reads.

### Limits

- It reads the register's own lists and the company numbers you name. A company outside the window, outside your pasted filters and not in `companyNumbers` is not fetched: there is no free-text name search.
- No contact details. The register does not publish a company's own website, email or phone. `register_page_url` and `register_urls` are the register's URLs for the company, not the company's site.
- No filing documents. `latest_filing` carries the filing's date, type and description and nothing more, by design.
- Officers, PSC and filing tabs cost one extra read per company each. All three flags on a big window mean a long run.
- One search tops out at 10,000 companies before the register's own list ends. A window wider than that is cut there.
- Memory lasts 31 days. A company that appears again after that is emitted once more, which is correct for a filings feed: a second appearance is a new event.
- `registrar` is always `Companies House`, and `country_of_origin` read `United Kingdom` on all 100 captured rows. One register means little variety.
- Errors run toward failing. A refused or changed page fails the run with the error in the log instead of emitting rows of nulls.

### Troubleshooting

**My scheduled run returned far fewer rows than `maxItems`.** The feed already sent the rest, or the SIC filter dropped them. The log line "companies in scope, new or status-changed, emitted" says which, and `RUN_SUMMARY` carries the counts.

**I got one `PROFILE_NOT_FOUND` row and nothing else.** That is an answer, not an error: the register answered and nothing new matched. It is not charged. On a second run over the same window it usually means the first run already sent everything.

**`officers`, `persons_with_significant_control` and `latest_filing` are all `null`.** They fill only when the matching input flag is on. Set `includeOfficers`, `includePsc` or `includeFilings` and re-run.

**The run failed with a "refused" error.** Companies House declined a read. The Actor stops rather than scrape through a block; wait and re-run, or set `proxyConfiguration`. A pasted `startUrls` link that is not an advanced-search results URL also fails the run, with the refused URL in the message.

Something still off? Open an issue on this Actor's **Issues** tab on the Apify Store.

### FAQ

**Can I use integrations with UK Companies House New Company Filings Scraper?**
Yes. The dataset plugs into Apify integrations such as Make, Zapier and webhooks, and an Apify schedule is the natural way to run it. A weekly schedule turns this Actor into a standing new-companies feed.

**Can I use UK Companies House New Company Filings Scraper with the Apify API?**
Yes. Start runs, read the dataset and manage schedules over the API. The curl line under "How do I use" is a working example; swap in your token and your input.

**Can I use UK Companies House New Company Filings Scraper through an MCP server?**
Yes. The command under "Use UK Companies House New Company Filings Scraper with AI agents" adds it to an MCP client, after which an agent can call it like any other tool.

**Is it legal to scrape Companies House?**
The register is public and published under statutory obligation. Its terms do not prohibit reading it this way, though permission is not explicit either. Rows carry register facts only, and the Personal data section covers the people named in them.

### Not affiliated

This Actor is not affiliated with, associated with, endorsed by or sponsored by Companies House or the UK government. It reads public pages of the UK company register and returns what they show.

# Actor input Schema

## `startUrls` (type: `array`):

Optional. Paste results URLs from the Companies House advanced search to read those filtered lists instead of the default incorporation and dissolution windows.

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

Optional. Companies House company numbers or company page URLs (for example 00000006 or .../company/00000006). Each produces one detailed row, charged per row: a number the register does not know comes back as an uncharged not\_found row. When given alone, no window or search is read.

## `searchQueries` (type: `array`):

Optional SIC filter. Each entry matches a SIC code prefix (like 43) or text in the SIC description (like restaurant); companies without a match are dropped.

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

Optional Apify proxy settings. When set, every request to the Companies House register goes through the configured proxy.

## `maxItems` (type: `integer`):

The most company rows one run returns (default 100).

## `maxItemsPerStartUrl` (type: `integer`):

Optional. Caps how many companies each pasted startUrls entry may contribute to a run, so one long list cannot spend the whole maxItems budget. Leave unset for one shared cap.

## `daysBack` (type: `integer`):

How many days back the incorporation and dissolution windows reach (default 7).

## `includeOfficers` (type: `boolean`):

Also read each company's officers tab: fills officers and first\_director. One extra request per company.

## `includePsc` (type: `boolean`):

Also read each company's persons-with-significant-control tab: fills persons\_with\_significant\_control. One extra request per company.

## `includeFilings` (type: `boolean`):

Also read each company's filing-history tab: fills latest\_filing with the newest filing's date, type and description. One extra request per company.

## Actor input object example

```json
{
  "maxItems": 100,
  "daysBack": 7,
  "includeOfficers": false,
  "includePsc": false,
  "includeFilings": false
}
```

# Actor output Schema

## `rows` (type: `string`):

The company rows this run emitted: one per newly incorporated or dissolved company, minus those already sent on earlier runs.

## `summary` (type: `string`):

The run's counts: rows fetched, pushed and charged, duplicates dropped, stopped early.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("pradio/new-company-filings").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("pradio/new-company-filings").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 '{}' |
apify call pradio/new-company-filings --silent --output-dataset

```

## MCP server setup

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

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/RZgX3vKaa3aLhVpwY/builds/ooapahHgThVz374bE/openapi.json