# UK & EU Grant Awards & Open Calls Intelligence (`sweet-orb/uk-eu-grant-intelligence`) Actor

Search UKRI Gateway to Research awards and EU Funding & Tenders Portal calls and projects in one dataset. Filter by keyword, sector, country, funder, amount, deadline and recipient organisation type. Returns recipient names, identifiers and source links. No personal data.

- **URL**: https://apify.com/sweet-orb/uk-eu-grant-intelligence.md
- **Developed by:** [Karol Olechno](https://apify.com/sweet-orb) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 calls

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

## UK & EU Grant Awards & Open Calls Intelligence

Search **UKRI Gateway to Research** awards and **EU Funding & Tenders Portal** calls, topics, tenders and awarded projects in one dataset. Filter by keyword, sector, country, funder, amount, deadline, status and recipient organisation type. Every record carries the recipient organisation, its native identifier and a link to the public source page. No personal data.

### What it does

- Queries two official public APIs: the UKRI Gateway to Research API and the European Commission's Funding & Tenders Portal search API.
- Returns one row per **call**, **tender**, **award** or **funded project**, with title, funder, programme, description, eligibility text, amount range, currency, opening and closing dates, normalised status, recipient organisation and identifiers.
- Filters by keywords (any-of), excluded keywords, sector/topic labels, countries, funders, amount range, status, deadline window and recipient organisation type.
- Merges, de-duplicates and sorts the results from both sources into a single dataset.
- Charges one pay-per-event unit per record written. Empty or failed runs do not charge per-record events.

### Who it is for

- **Bid writers and grant consultants** tracking open calls and recent awards in their sectors.
- **SMEs, startups and charities** looking for UK and EU funding they can apply for.
- **Sales, partnership and market-intelligence teams** mapping who won what, how much and where.
- **AI agents** that need a structured, filterable grant and award feed.

### Data sources and coverage

| Source | What it covers | Currency | API |
|---|---|---|---|
| UKRI Gateway to Research | UK research and innovation projects and awards: grant reference, title, status, grant category, lead funder, abstract, research topics, participants, project cost and grant offer | GBP | `https://gtr.ukri.org/gtr/api/` |
| EU Funding & Tenders Portal | Calls for proposals, grant topics and external actions (types 1 and 2), awarded projects (`SEDIA_NONH2020_PROD` index) and optional procurement tenders (type 0) | EUR | `https://api.tech.ec.europa.eu/search-api/prod/rest/search` |

The EU portal's public search API is used without login. UKRI's Gateway to Research API is public. The Actor sends a normal browser User-Agent and the portal's documented Referer/Origin headers, retries with exponential backoff and never bypasses authentication or robots controls.

**Coverage notes**

- UKRI records are awards/projects. Their opening and closing dates are the project start and end dates, not application deadlines.
- EU calls and topics may include historical records whose published status is stale. The Actor derives `open`/`closed`/`forthcoming` from the published dates first and falls back to the source status label.
- EU call amounts are the total topic or action budget parsed from the portal's `budgetOverview`, not a per-grant minimum and maximum. EU project amounts are the published EU contribution.
- Organisation type is inferred from the legal name when the source does not state a type. The inference is documented in the input schema and is deliberately conservative.
- The EU projects index uses EC numeric country codes internally; the Actor converts the documented codes to ISO 2-letter codes for the output.

### Output fields

| Field | Description |
|---|---|
| `id` | Stable record ID (`ukri:<GTR id>` or `eu:<reference>`) |
| `source` | `ukri` or `eu` |
| `recordType` | `call`, `tender`, `award` |
| `title` | Award, call or project title |
| `funder` | Funder or funding body |
| `programme` | Programme, scheme or call family |
| `description` | Plain-text summary or objective (HTML removed) |
| `whoCanApply` | Eligibility text for calls/tenders, or the recipient description for awards/projects |
| `amountMin`, `amountMax` | Amount range in the source currency |
| `currency` | `GBP` or `EUR` |
| `openingDate`, `closingDate` | Opening and closing dates (project start/end for awards) |
| `status` | `open`, `closed`, `forthcoming`, `active`, `unknown` |
| `organisation` | Recipient organisation for awards/projects, or the funder for calls/tenders: name, type, native identifier, country, role |
| `topics` | Source taxonomy topics, tags or subject labels |
| `identifiers` | Native IDs: GTR project ID and grant reference; EU reference, topic, call and programme IDs |
| `sourceUrl` | Canonical public page |
| `lastUpdated` | Source last-updated date when published |
| `fetchedAt` | When the record was fetched |

### Input

All filters are optional. With no input you get up to 100 open EU calls and active UKRI/EU awards. See `.actor/input_schema.json` for full descriptions.

| Input | Type | Default | Notes |
|---|---|---|---|
| `sources` | array | `["ukri","eu"]` | Which public sources to search |
| `recordTypes` | array | `["call","award"]` | Add `tender` for EU procurement notices |
| `keywords` | array | `[]` | Any-of substring match across title, description, programme, topics, organisation and identifiers |
| `excludeKeywords` | array | `[]` | Drop matches |
| `sectors` | array | `[]` | Match only the source taxonomy fields |
| `countries` | array | `[]` | ISO 2-letter codes or names; EU/Europe for EU-wide calls |
| `funders` | array | `[]` | Funder, programme, call or programme ID text |
| `amountMin`, `amountMax` | number | unset | In the source's own currency (GBP for UKRI, EUR for EU) |
| `status` | array | `["open","active"]` | `open`, `closed`, `forthcoming`, `active`, `any` |
| `deadlineFrom`, `deadlineTo` | string | unset | `YYYY-MM-DD` or relative `30 days` / `6 months` from today |
| `organisationTypes` | array | `["any"]` | Filters award recipients; calls and tenders pass |
| `sortBy` | string | `newest` | `newest`, `closingSoon`, `amountDesc` |
| `maxResults` | integer | 100 | 1–5,000; charged per record returned |

### Sample output

```json
{
  "id": "eu:50143353TOPICSen",
  "source": "eu",
  "recordType": "call",
  "title": "Developing novel recycling technologies for complex plastic materials applying biotech solutions",
  "funder": "European Commission",
  "programme": "Call 01 - single stage (2027)",
  "description": "Expected Outcome: Project results are expected to contribute to ...",
  "whoCanApply": "General conditions 1. Admissibility Conditions: ...",
  "amountMin": 261800000,
  "amountMax": 261800000,
  "currency": "EUR",
  "openingDate": "2027-04-20",
  "closingDate": "2027-09-22",
  "status": "forthcoming",
  "organisation": {
    "name": "European Commission",
    "type": "public-body",
    "identifier": null,
    "country": "EU",
    "role": "funder"
  },
  "topics": ["biotechnology", "HORIZON-CL6-2027-01-CIRCBIO-03", "Circular economy"],
  "identifiers": {
    "euReference": "50143353TOPICSen",
    "topicIdentifier": "HORIZON-CL6-2027-01-CIRCBIO-03",
    "callIdentifier": "HORIZON-CL6-2027-01",
    "programmeId": "43108390"
  },
  "sourceUrl": "https://ec.europa.eu/info/funding-tenders/opportunities/portal/screen/opportunities/topic-details/HORIZON-CL6-2027-01-CIRCBIO-03",
  "lastUpdated": "2027-04-20",
  "fetchedAt": "2026-11-03T23:32:40.213Z"
}
```

### Pricing

**$0.02 per record** (`grant-record` event), i.e. **$20 per 1,000 records**.

- You are charged only for records written to the dataset. An empty or failed run does not charge per-record events.
- The Actor does not add an actor-start event. Standard Apify platform usage may apply separately.
- Set the run's maximum cost to cap spend. The Actor stops cleanly when the cap is reached and reports how many records it saved.
- Local test runs with the pay-per-event pricing environment variable use the same $0.02 price per event; the local charging log records each event.

### Use with AI agents (MCP)

This Actor is designed to be called by AI agents:

- Every input field has a human- and agent-readable description, enums, defaults and constraints in `.actor/input_schema.json`.
- The output schema exposes the full dataset and a compact `overview` view.
- Connect it through Apify's MCP server (see the Apify docs for the current MCP endpoint) or call the Actor's API endpoint directly from your agent tool. The input is a single JSON object; the output is a JSON array of grant records.

### FAQ

**How fresh is the data?** Every run queries the live public APIs. There is no cached database. UKRI and EU updates appear on the next run.

**Why do I sometimes get only EU records?** The default `newest` sort uses the opening date. EU calls with future opening dates sort ahead of older UKRI awards. Use `sortBy: "closingSoon"`, `status: ["active"]`, or `sources: ["ukri"]` to surface UKRI awards.

**Why do some records have no amount?** The source did not publish a budget or contribution. Records without an amount are dropped when `amountMin` or `amountMax` is set.

**Why does an EU call show a huge amount?** EU call amounts are the total topic/action budget from the portal's `budgetOverview`, not the maximum grant per applicant. Use the call's source page for the per-grant contribution rules.

**Can I get only companies?** Set `organisationTypes: ["company"]`. This filters awards and funded projects. Calls and tenders still pass because they have no recipient yet; use keywords or sectors to narrow them.

**Are tenders included?** Only when `recordTypes` includes `tender`. Tenders are EU procurement notices (type 0) and are excluded by default.

**Does it collect personal data?** No. The Actor returns organisation names and organisation identifiers only. It does not return individual names, emails or phone numbers.

**Is this affiliated with UKRI or the European Commission?** No. It is an independent data product that queries public APIs. It is not endorsed by UKRI or the European Commission.

### Data quality and attribution

- Contains public sector information from UKRI and the European Commission.
- Source data is published by UKRI and the European Commission; check each source page for the applicable licence, attribution and reuse terms.
- The publisher cannot warrant the quality or accuracy of the data. Records can be incomplete, stale or misclassified. Always verify a funding opportunity on its source page before applying.
- The Actor is not affiliated with or endorsed by UKRI, Innovate UK or the European Commission.

### Development

```bash
npm install
npm test
npx -y apify-cli@1.11.0 validate-schema
npm run test:live
```

`npm run test:live` runs the Actor locally with `test/live-input.json`, pay-per-event pricing enabled and the charging log dataset turned on. Output lands in `storage/datasets/default/`, charges in `storage/datasets/charging_log/` and the run summary in `storage/key_value_stores/default/RUN_SUMMARY.json`.

# Actor input Schema

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

Which public sources to search. ukri = UKRI Gateway to Research projects and awards (UK, GBP). eu = EU Funding & Tenders Portal calls, topics, tenders and awarded projects (EUR). Leave empty for both. Sources are queried separately and merged into one dataset.

## `recordTypes` (type: `array`):

call = open and closed calls for proposals and grant topics. award = funded projects and grants already awarded. tender = EU procurement notices (calls for tenders). Default: call + award. Add tender if you also bid on public contracts.

## `keywords` (type: `array`):

Return records whose title, description, programme, topics, organisation name or identifiers contain ANY of these phrases (case-insensitive substring match). Examples: "biotech", "battery storage", "AI", "clinical trial". Leave empty for all records; provide one or more keywords for useful results.

## `excludeKeywords` (type: `array`):

Drop records whose searchable text contains any of these phrases. Example: "military", "defence", "nuclear".

## `sectors` (type: `array`):

Match ONLY against the source's topic and tag taxonomy fields (UKRI research subjects/topics/programmes; EU tags, keywords, call title and programme), not the free-text description. Examples: "industrial biotechnology", "clean energy", "digital health".

## `countries` (type: `array`):

ISO 2-letter country codes or names. UKRI awards are UK-only: include GB or UK to keep them. EU awarded projects are matched by coordinator country (e.g. DE, FR, NL) or include EU/Europe to keep all. EU calls and tenders are EU-wide and pass only when the list includes EU/Europe/EU-wide. Leave empty for all.

## `funders` (type: `array`):

Match funder, programme, call identifier or programme ID text. Examples: "Innovate UK", "Horizon Europe", "ERC", "EIC", "UKRI". Leave empty for all.

## `amountMin` (type: `number`):

Only return records whose amount range reaches at least this value. Amounts are in the source's own currency: GBP for UKRI, EUR for EU. Records with no amount are dropped when either amount filter is set. Example: 100000.

## `amountMax` (type: `number`):

Only return records whose amount range starts at or below this value. In source currency (GBP for UKRI, EUR for EU). Example: 2000000.

## `status` (type: `array`):

open = calls/tenders whose closing date is today or later. closed = closing date in the past. forthcoming = opening date in the future. active = awards or projects still running. any = all. Default: open + active.

## `deadlineFrom` (type: `string`):

Earliest closing date, inclusive. Accepts YYYY-MM-DD (e.g. "2026-12-01") or a relative period from today (e.g. "30 days", "6 months"). For awards, the closing date is the project end date. Records without a closing date are dropped when this or deadlineTo is set.

## `deadlineTo` (type: `string`):

Latest closing date, inclusive. Accepts YYYY-MM-DD or a relative period from today. Use with deadlineFrom to get e.g. calls closing in the next 90 days.

## `organisationTypes` (type: `array`):

Filter awards and funded projects by recipient type. company, charity, university, public-body, research-institute, other or unknown. The type is inferred from the legal name when the source does not state one. Calls and tenders always pass because they have no recipient yet. Default: any.

## `sortBy` (type: `string`):

newest = most recent opening date first. closingSoon = earliest closing date first. amountDesc = largest amount first. Records without the sort field go last.

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

Stop after this many matching records. You are charged per record returned, so keep this low for exploratory or agent queries. 1–5,000.

## Actor input object example

```json
{
  "sources": [
    "ukri",
    "eu"
  ],
  "recordTypes": [
    "call",
    "award"
  ],
  "keywords": [],
  "status": [
    "open",
    "active"
  ],
  "organisationTypes": [
    "any"
  ],
  "sortBy": "newest",
  "maxResults": 100
}
```

# Actor output Schema

## `results` (type: `string`):

All matching records with title, funder, programme, description, eligibility, amounts, currency, opening and closing dates, status, recipient organisation and identifiers, topics and source URL.

## `overview` (type: `string`):

The same records in the compact overview view of the dataset.

# 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 = {
    "keywords": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("sweet-orb/uk-eu-grant-intelligence").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 = {
    "keywords": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("sweet-orb/uk-eu-grant-intelligence").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 '{
  "keywords": [],
  "maxResults": 100
}' |
apify call sweet-orb/uk-eu-grant-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sweet-orb/uk-eu-grant-intelligence"
        }
    }
}
```

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/K6D7Z8pJ1kgl3xC60/builds/wXBDRHaUS58k3Onxe/openapi.json