# UK Find a Tender Scraper (`automation-lab/uk-find-a-tender-scraper`) Actor

Scrape UK Find a Tender notices, buyers, deadlines, values, CPV codes, suppliers, awards, and document links from public pages.

- **URL**: https://apify.com/automation-lab/uk-find-a-tender-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## UK Find a Tender Scraper

Extract public UK procurement notices from Find a Tender for bid monitoring, sales intelligence, award tracking, and market research.

### What does UK Find a Tender Scraper do?

UK Find a Tender Scraper collects public notices from the official UK Find a Tender service.

It reads search result pages and notice detail pages.

It saves one dataset item per procurement notice.

It is designed for high-value UK public procurement monitoring.

Typical records include notice identifiers, titles, buyers, deadlines, values, CPV codes, locations, summaries, suppliers, award data, source URLs, and document links.

### Who is it for?

This actor is for B2G sales teams.

It is for bid managers.

It is for procurement analysts.

It is for tender monitoring teams.

It is for consultants tracking public sector demand.

It is for SaaS teams selling into central government, councils, NHS bodies, universities, and utilities.

### Why use it?

Find a Tender is the UK service for higher-value public procurement notices.

Manual monitoring is repetitive.

Official pages are public but not convenient for automated analysis.

This actor turns public pages into structured data.

You can run it daily to find new opportunities.

You can run it weekly to monitor awards.

You can enrich CRM accounts with buying signals.

### How it works

The actor uses HTTP requests and Cheerio HTML parsing.

It does not require a browser.

It does not require a Find a Tender account.

It fetches search pages first.

It can then fetch each notice detail page.

Detail fetching enriches records with document links, CPV-like codes, supplier text, and award text when those details are visible.

### Data you can extract

| Field | Description |
| --- | --- |
| `noticeId` | Find a Tender notice identifier |
| `title` | Notice title |
| `buyer` | Buyer or contracting authority |
| `publicationDate` | Publication date text |
| `deadline` | Submission, closing, or engagement deadline |
| `noticeType` | Notice type or stage |
| `noticeStatus` | Inferred open or awarded status when possible |
| `value` | Contract or total value text |
| `cpv` | CPV/category codes found on details |
| `categories` | Category or section headings |
| `location` | Contract location |
| `description` | Search summary or page description |
| `supplier` | Supplier name when present |
| `awardData` | Award-related text when present |
| `sourceUrl` | Original notice URL |
| `documentLinks` | Public document/download links |

### How much does it cost to scrape UK Find a Tender?

This actor uses pay-per-event pricing.

There is a small start charge for each run: **$0.005**.

There is a per-result charge for each saved notice. The default BRONZE tier is approximately **$0.000051827 per notice**. Other Apify tiers use the configured tiered result prices: FREE **$0.000059601**, SILVER **$0.000040425**, GOLD **$0.000031096**, PLATINUM **$0.000020731**, and DIAMOND **$0.000014512** per notice.

Example: a run that saves 100 notices costs about **$0.0102** at the BRONZE tier before any platform-specific taxes or account-level billing adjustments: $0.005 start + 100 × $0.000051827.

Use a low `maxResults` value for first tests.

Increase `maxResults` only after you confirm the output matches your workflow.

### Input options

`keywords` searches and filters procurement notices by text.

`noticeStatus` keeps all notices, open notices, or closed/awarded notices.

`noticeTypes` lets you keep notices whose type text contains values such as `Award`, `Tender`, `UK4`, or `F03`.

`buyer` filters buyer or authority names.

`cpvCode` filters parsed CPV/category text.

`dateFrom` and `dateTo` filter parsed publication dates inclusively. Use `YYYY-MM-DD`.

`maxResults` controls the number of dataset rows.

`fetchDetails` controls whether the actor opens each detail page.

`startUrls` accepts Find a Tender search URLs or direct notice URLs.

### Example input

```json
{
  "keywords": "software",
  "noticeStatus": "all",
  "noticeTypes": ["Award", "Tender"],
  "maxResults": 10,
  "fetchDetails": true,
  "startUrls": [
    { "url": "https://www.find-tender.service.gov.uk/Search/Results" }
  ]
}
````

### Example output

```json
{
  "noticeId": "056146-2026",
  "title": "Maintenance of Pharmacy Robot",
  "buyer": "NHS Wales Shared Services Partnership-Procurement Services",
  "publicationDate": "15 June 2026, 12:27pm",
  "deadline": null,
  "noticeType": "F03: Contract award notice",
  "noticeStatus": "Awarded",
  "value": "£65,513.30",
  "cpv": [],
  "categories": [],
  "location": "UKL14 - South West Wales",
  "description": "This contract covers the maintenance and servicing...",
  "supplier": "Becton Dickinson Dispensing UK Limited",
  "awardData": "Supplier: Becton Dickinson Dispensing UK Limited",
  "sourceUrl": "https://www.find-tender.service.gov.uk/Notice/056146-2026?origin=SearchResults&p=1",
  "documentLinks": []
}
```

### Step-by-step guide

1. Open the actor on Apify.

2. Enter keywords such as `software`, `construction`, `cloud`, or `security`.

3. Choose whether to keep all notices or focus on open opportunities.

4. Add optional notice type filters.

5. Set `maxResults` to a small value for the first run.

6. Keep `fetchDetails` enabled if you need supplier or document links.

7. Start the run.

8. Export results as JSON, CSV, Excel, or via API.

### Start URL workflows

Use a search result URL when you want the actor to collect notices from search pages.

Use a notice URL when you want to enrich one known notice.

You can combine multiple start URLs.

The actor deduplicates visited page URLs during a run.

### Bid monitoring workflow

Run the actor every morning.

Filter by terms related to your product or service.

Send results to a CRM or spreadsheet.

Review deadlines and buyer names.

Assign owners to qualified opportunities.

Track repeated buyers over time.

### Award intelligence workflow

Set notice type filters to award-related terms.

Review suppliers and values.

Identify competitors that repeatedly win contracts.

Use buyer names and award data to plan renewal outreach.

Monitor framework and call-off activity.

### Integrations

Use Apify datasets to export CSV or Excel.

Use the Apify API to pull JSON into a data warehouse.

Use Zapier or Make to send new notices to Slack.

Use webhooks to notify bid teams after each scheduled run.

Use Google Sheets integrations for lightweight monitoring lists.

Use CRM enrichment workflows to attach procurement signals to accounts.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/uk-find-a-tender-scraper').call({
  keywords: 'software',
  maxResults: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/uk-find-a-tender-scraper').call(run_input={
    'keywords': 'software',
    'maxResults': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~uk-find-a-tender-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":"software","maxResults":10}'
```

### MCP usage

You can use this actor from Apify MCP tools.

Claude Code MCP URL:

`https://mcp.apify.com/?tools=automation-lab/uk-find-a-tender-scraper`

Claude Code add command:

```bash
claude mcp add apify-uk-find-a-tender https://mcp.apify.com/?tools=automation-lab/uk-find-a-tender-scraper
```

Claude Desktop MCP URL:

`https://mcp.apify.com/?tools=automation-lab/uk-find-a-tender-scraper`

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-uk-find-a-tender": {
      "url": "https://mcp.apify.com/?tools=automation-lab/uk-find-a-tender-scraper"
    }
  }
}
```

Example prompt:

"Run the UK Find a Tender Scraper for cyber security notices and summarize open opportunities closing this month."

Another prompt:

"Find recent award notices for cloud software and list winning suppliers, values, and buyers."

### Tips for better results

Use specific keywords.

Try buyer names for account-based monitoring.

Use notice type filters to focus on tenders or awards.

Keep `fetchDetails` enabled for richer output.

Increase `maxResults` gradually.

Schedule recurring runs for monitoring.

Deduplicate downstream by `noticeId`.

### Troubleshooting

If you get fewer results than expected, remove filters and try again.

If document links are empty, the notice may not expose public attachment links in the parsed page.

If supplier data is empty, the notice may be an opportunity rather than an award.

If keyword filtering feels broad, use more specific terms or filter downstream.

### Limitations

The actor extracts public data only.

It does not sign in.

It does not bypass access controls.

The site may use different templates for different notice types.

Some fields are optional and appear only when Find a Tender publishes them.

Date fields are currently stored as source text to preserve official wording.

### Legality

Find a Tender publishes public procurement notices.

You are responsible for using the data lawfully.

Respect applicable procurement, privacy, and database rules.

Do not use the actor to overload the source website.

Use reasonable result limits and schedules.

### Related scrapers

Contracts Finder UK Procurement Scraper: `https://apify.com/automation-lab/contracts-finder-uk-procurement-scraper`

TED Europa Tenders Scraper: `https://apify.com/automation-lab/ted-europa-tenders-scraper`

Use this actor when your workflow specifically targets the UK Find a Tender portal.

Use Contracts Finder for lower-value UK opportunities listed on Contracts Finder.

Use TED for EU-wide procurement monitoring.

### FAQ

#### Is a Find a Tender account required?

No. The actor uses public search and notice pages.

#### Can I scrape award notices?

Yes. Award notice fields such as supplier, value, and award text are saved when visible.

#### Can I monitor one buyer?

Yes. Use the `buyer` input or filter exported data by buyer name.

#### Can I get documents?

The actor saves public document/download links that appear on notice pages.

#### Can I run it every day?

Yes. Daily runs are a good fit for bid monitoring.

#### Does it use a browser?

No. It uses HTTP and HTML parsing for efficient runs.

#### What if the official page layout changes?

The actor uses resilient selectors, but a major source-site redesign may require an update.

### Changelog

Initial version extracts public Find a Tender search and notice data.

### Support

Open an issue on Apify if a public notice URL fails or a field is missing from pages where it is clearly visible.

# Actor input Schema

## `keywords` (type: `string`):

Words or phrases to match in notice titles, descriptions, identifiers, buyers, and categories.

## `noticeStatus` (type: `string`):

Limit output to open opportunities, closed/awarded notices, or all notices.

## `noticeTypes` (type: `array`):

Optional notice type or stage text to keep, for example Tender, Award, UK4, F03, Preliminary market engagement.

## `buyer` (type: `string`):

Optional buyer or contracting authority text filter.

## `cpvCode` (type: `string`):

Optional CPV code or category text filter applied to parsed notice fields.

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

Optional date boundary for workflows. Use YYYY-MM-DD.

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

Optional date boundary for workflows. Use YYYY-MM-DD.

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

Maximum number of notices to save.

## `fetchDetails` (type: `boolean`):

Open each notice detail page to enrich records with CPV/category, supplier/award text, and document links.

## `useApifyProxy` (type: `boolean`):

Enable Apify SHADER/datacenter proxy if the source temporarily rate-limits direct requests. Usually not needed.

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

Optional Find a Tender search result or notice detail URLs. Leave empty to start from the standard search page.

## Actor input object example

```json
{
  "keywords": "software",
  "noticeStatus": "all",
  "noticeTypes": [
    "Award",
    "Tender"
  ],
  "maxResults": 10,
  "fetchDetails": true,
  "useApifyProxy": false,
  "startUrls": [
    {
      "url": "https://www.find-tender.service.gov.uk/Search/Results"
    }
  ]
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": "software",
    "noticeTypes": [
        "Award",
        "Tender"
    ],
    "maxResults": 10,
    "startUrls": [
        {
            "url": "https://www.find-tender.service.gov.uk/Search/Results"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/uk-find-a-tender-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 = {
    "keywords": "software",
    "noticeTypes": [
        "Award",
        "Tender",
    ],
    "maxResults": 10,
    "startUrls": [{ "url": "https://www.find-tender.service.gov.uk/Search/Results" }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/uk-find-a-tender-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 '{
  "keywords": "software",
  "noticeTypes": [
    "Award",
    "Tender"
  ],
  "maxResults": 10,
  "startUrls": [
    {
      "url": "https://www.find-tender.service.gov.uk/Search/Results"
    }
  ]
}' |
apify call automation-lab/uk-find-a-tender-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/uk-find-a-tender-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK Find a Tender Scraper",
        "description": "Scrape UK Find a Tender notices, buyers, deadlines, values, CPV codes, suppliers, awards, and document links from public pages.",
        "version": "0.1",
        "x-build-id": "7mvgyz4xBnnkocVlS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~uk-find-a-tender-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-uk-find-a-tender-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/automation-lab~uk-find-a-tender-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-uk-find-a-tender-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/automation-lab~uk-find-a-tender-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-uk-find-a-tender-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",
                "properties": {
                    "keywords": {
                        "title": "🔎 Keywords",
                        "type": "string",
                        "description": "Words or phrases to match in notice titles, descriptions, identifiers, buyers, and categories."
                    },
                    "noticeStatus": {
                        "title": "Notice status",
                        "enum": [
                            "all",
                            "open",
                            "closed"
                        ],
                        "type": "string",
                        "description": "Limit output to open opportunities, closed/awarded notices, or all notices.",
                        "default": "all"
                    },
                    "noticeTypes": {
                        "title": "Notice type filters",
                        "type": "array",
                        "description": "Optional notice type or stage text to keep, for example Tender, Award, UK4, F03, Preliminary market engagement.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "buyer": {
                        "title": "Buyer / authority contains",
                        "type": "string",
                        "description": "Optional buyer or contracting authority text filter."
                    },
                    "cpvCode": {
                        "title": "CPV code contains",
                        "type": "string",
                        "description": "Optional CPV code or category text filter applied to parsed notice fields."
                    },
                    "dateFrom": {
                        "title": "Publication date from",
                        "type": "string",
                        "description": "Optional date boundary for workflows. Use YYYY-MM-DD."
                    },
                    "dateTo": {
                        "title": "Publication date to",
                        "type": "string",
                        "description": "Optional date boundary for workflows. Use YYYY-MM-DD."
                    },
                    "maxResults": {
                        "title": "Maximum notices",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of notices to save.",
                        "default": 25
                    },
                    "fetchDetails": {
                        "title": "Fetch notice detail pages",
                        "type": "boolean",
                        "description": "Open each notice detail page to enrich records with CPV/category, supplier/award text, and document links.",
                        "default": true
                    },
                    "useApifyProxy": {
                        "title": "Use Apify datacenter proxy",
                        "type": "boolean",
                        "description": "Enable Apify SHADER/datacenter proxy if the source temporarily rate-limits direct requests. Usually not needed.",
                        "default": false
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Find a Tender search result or notice detail URLs. Leave empty to start from the standard search page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
