# Recently funded UK companies (SH01) (`data_blume/uk-funding-rounds`) Actor

UK companies that have just issued shares, read from the SH01 forms they file at Companies House: amount raised, price per share, shares issued and date. It can include issues never announced to the press.

- **URL**: https://apify.com/data_blume/uk-funding-rounds.md
- **Developed by:** [Tim Blume](https://apify.com/data_blume) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 funding round rows

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

### What is UK Funding Rounds?

UK Funding Rounds gives you UK share issues, read from the share allotment forms that companies file at Companies House: who issued shares, how many, at what price, how much was raised and when.

When a UK company limited by shares issues new shares, it must file a form called an SH01 with Companies House within one month. We read those forms ourselves, so the data can include share issues that were never announced to the press. Typed forms are read by code. Scanned paper forms are flagged, not read, until we add text recognition.

Search by company, date, amount or kind of issue. Each row links to the original filing and says how it was read.

### Who it is for

- Investors and funds tracking UK private companies
- Lenders, advisers and corporate finance teams
- Sales teams looking for companies that have just raised money
- Journalists and researchers

### What data does it return?

One row per share issue:

| Field | What it is |
| --- | --- |
| `transaction_id` | Companies House's id for the filing |
| `company_number` | Companies House number |
| `company_name` | Company name on the filing |
| `round_date` | Last allotment date on the filing |
| `kind` | `premium_issue` (shares sold above their nominal value, usually an investment round, sometimes option exercises), `par_issue` (at nominal value, usually founders or owners), `non_cash` (issued for something other than cash, such as a share exchange), `mixed`, or `unclear` (the form contradicts itself, so no price is given) |
| `currency` | Currency of the shares |
| `shares_issued` | Number of shares allotted |
| `price_per_share` | Amount paid per share, including premium |
| `amount` | Shares allotted times amount paid per share. For non_cash rows it is the value given for the shares, not cash raised |
| `total_shares_after` | Total shares in issue, from the form's statement of capital. When a company files several late forms together, this is the total when the form was filed |
| `implied_valuation` | Price per share times total shares after, for premium issues only (empty for the other kinds); a rough figure that assumes every class is worth the same |
| `classes` | Share classes issued |
| `notes` | Anything unusual about the filing |
| `filed_on` | Date Companies House received the form |
| `source_url` | The original filing |
| `fetched_at` | When the filing was fetched |
| `read_method` | How the form was read: `code`, `text_recognition`, `claude` or `manual` |

### How to use it

1. Add filters if you want them: `company` (a Companies House number, or part of a company name), `from` and `to` (round dates, YYYY-MM-DD), `min_amount` and `kind`. Leave them all empty to get the most recent share issues; put a company number in `company` to get the issues we hold for that company.
2. Choose `max_rows`, the most rows you want (default 20). Rows come newest round date first.
3. Run it. The rows are the run's results. You can download them as JSON, CSV, XML, Excel, an HTML table, RSS or JSONL, or read them with Apify's API.

To see only likely investment rounds, set `kind` to `premium_issue` and choose a `min_amount`.

### How much does it cost?

USD 0.05 for each row a run returns (one row is one share issue), plus Apify's start charge of USD 0.00005 a run. Apify charges both to your Apify account.

### Input example

```json
{
  "kind": "premium_issue",
  "min_amount": 1000000,
  "max_rows": 20
}
```

### Output example

```json
{
  "transaction_id": "MzQ5Njg0MTU3NWFkaXF6a2N4",
  "company_number": "15329764",
  "company_name": "Mar Hall Hospitality Limited",
  "round_date": "2025-12-30",
  "filed_on": "2025-12-30",
  "kind": "par_issue",
  "currency": "GBP",
  "shares_issued": "10200000",
  "price_per_share": "1",
  "amount": "10200000.00",
  "total_shares_after": "24200100",
  "implied_valuation": null,
  "classes": [
    "A ORDINARY"
  ],
  "notes": null,
  "source_url": "https://find-and-update.company-information.service.gov.uk/company/15329764/filing-history/MzQ5Njg0MTU3NWFkaXF6a2N4/document?format=pdf&download=0",
  "fetched_at": "2026-09-26T16:55:40+00:00",
  "read_method": "code"
}
```

### Where does the data come from?

Companies House, the UK's register of companies. The form is the SH01, "return of allotment of shares". The law behind it is the Companies Act 2006, section 555: a company must file a return of allotment within one month of allotting shares.

What Companies House says about using the information is quoted in full under FAQ.

### What is covered

In a random sample of 400 active private companies, 40 share allotment forms were filed from January 2023: 37 were typed and read by code, and 3 were scanned paper that needs text recognition. Scanned forms are flagged until text recognition is added. Public companies and companies incorporated since 1 September 2025 were outside that sample.

New filings are picked up every morning at about 05:15 UTC. The data starts on 18 October 2026, when our update first read Companies House's filings: filings received before then are not included.

### Limits

- The SH01 form does not name who bought the shares, so there are no investor names.
- Most share issues are not investment rounds. Every row says what kind of issue it is, so you can filter.
- `implied_valuation` is rough: it assumes every class of share is worth the same.
- A form can reach Companies House weeks after the shares were issued.

### FAQ

**Are there rules on using this data?** Companies House says: "We impose no rules or requirements on how the information on the public register is used, and we're not responsible for your use of the company data. You are responsible for complying with any applicable data protection, copyright and other legislation and regulations." (https://www.gov.uk/guidance/companies-house-data-products, read 23 September 2026)

**Does it include investors?** No. The form does not name them.

**Can AI assistants use it?** Apify's MCP server lets AI agents find and run Store Actors: it "enables AI agents to discover and run Actors from Apify Store" (Apify's documentation).

**How fresh is it?** Every morning at about 05:15 UTC we read the forms Companies House received since the day before. When our daily update has not finished for more than 48 hours, the run's status message says so and gives the time the data runs up to; if our daily update ever missed a period of filings, every run's status message names that period. The data starts on 18 October 2026.

**Does it include every share issue?** No. It includes the forms we have read: typed forms are read by code, and scanned paper forms are flagged until text recognition is added (3 of the 40 forms in our test sample were scanned). Public companies were outside that sample, so how well they are covered is not known yet.

### Support

Not affiliated with or endorsed by Companies House.

Email hello@datablume.com. Sold by Datablume, a sole trader business based in Scotland.

# Actor input Schema

## `company` (type: `string`):

Company number (exact) or part of the company name. For example 15329764, SC123456 or hospitality, in any case. Leave empty for every company.

## `from` (type: `string`):

Earliest round date, YYYY-MM-DD. The round date is the last allotment date on the form.

## `to` (type: `string`):

Latest round date, YYYY-MM-DD.

## `min_amount` (type: `number`):

Smallest amount raised, in the currency of the shares (most are GBP). For example 1000000. For non_cash rows the amount is the value given for the shares, not cash raised.

## `kind` (type: `string`):

Kind of share issue. premium_issue: shares sold above their nominal value, usually an investment round, sometimes option exercises. par_issue: at nominal value, usually founders or owners. non_cash: issued for something other than cash, such as a share exchange. mixed: share classes on the same form fall into different kinds. unclear: the form contradicts itself, so no price is given. Leave empty for every kind.

## `max_rows` (type: `integer`):

The most rows to return, from 1 to 1,000,000. They are fetched 100 at a time, newest round date first.

## Actor input object example

```json
{
  "max_rows": 20
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("data_blume/uk-funding-rounds").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("data_blume/uk-funding-rounds").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 data_blume/uk-funding-rounds --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_blume/uk-funding-rounds"
        }
    }
}
```

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/eYk6eBa6UPYgVxFjF/builds/XJvj4tfHbmFcwkS8V/openapi.json