# UNGM Tender Notices Scraper (`automation-lab/ungm-tender-notices-scraper`) Actor

Scrape public UNGM procurement notices with agencies, countries, deadlines, documents, contacts, and tender detail links.

- **URL**: https://apify.com/automation-lab/ungm-tender-notices-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **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

## UNGM Tender Notices Scraper

Extract United Nations Global Marketplace (UNGM) procurement opportunities from public tender search results and detail pages.

The actor helps suppliers, bid teams, procurement analysts, and market-intelligence workflows monitor UN tender notices by keyword, agency, country, deadline, notice type, reference number, and category.

### What does UNGM Tender Notices Scraper do?

UNGM Tender Notices Scraper searches the public UNGM opportunity database at `https://www.ungm.org/Public/Notice` and saves structured tender records to an Apify dataset.

It can collect:

- 🔎 Tender titles and UNGM notice IDs
- 🏛️ UN agencies and agency IDs
- 🌍 Beneficiary countries or territories
- 📅 Publication dates and deadlines
- 🧾 Notice types and reference numbers
- 📄 Public document download links
- 🔗 External supplier portal links
- 👤 Public procurement contact details
- 🧩 UNSPSC/category text when available

### Who is it for?

#### Suppliers and business development teams

Use the scraper to build a daily pipeline of relevant United Nations tenders and quickly identify opportunities that match your products, countries, and deadlines.

#### Bid and proposal teams

Export structured notices into a CRM, spreadsheet, data warehouse, or notification workflow so proposal managers can triage deadlines and document links.

#### Procurement-intelligence analysts

Track opportunity volume by agency, country, sector, or keyword. Use the output for market maps, competitor monitoring, and public-sector sales planning.

#### Consultants and NGOs

Monitor donor-funded procurement opportunities without manually checking UNGM search pages every day.

### Why use this UNGM scraper?

Manual UNGM monitoring is slow when you need to repeat the same searches across agencies, countries, categories, or deadline windows.

This actor turns public UNGM search results into repeatable structured data that can be scheduled, exported, and integrated.

### What data can you extract?

| Field | Description |
| --- | --- |
| `noticeId` | UNGM notice identifier |
| `title` | Tender or procurement opportunity title |
| `agency` | UN agency shown in the search result |
| `noticeType` | Invitation to bid, request for proposal, RFQ, EOI, and similar types |
| `reference` | Agency or UNGM reference number |
| `countries` | Beneficiary countries or territories |
| `publishedDate` | Publication date shown by UNGM |
| `deadline` | Deadline and timezone text |
| `remainingDays` | Remaining-days metadata when UNGM provides it |
| `detailUrl` | Public UNGM notice detail URL |
| `description` | Long notice description from detail pages |
| `documentLinks` | Public document download links |
| `contacts` | Public contact names and email addresses |
| `externalLinks` | Supplier portal or bid submission links |
| `unspscCodes` | UNSPSC/category text from detail pages |
| `scrapedAt` | Timestamp when the record was saved |

### How much does it cost to scrape UNGM tender notices?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a per-notice fee for each tender record saved to the dataset. The final platform price is shown on the Apify Store page before you run the actor.

To control cost:

- Start with a low `maxItems` value.
- Use keyword, country, agency, and date filters.
- Turn off `includeDetails` when you only need search-result fields.
- Schedule focused searches instead of one broad full-database run.

### How to scrape UNGM tenders

1. Open the actor on Apify.
2. Enter a keyword such as `medical supplies`, `vehicles`, `construction`, or `consultancy`.
3. Optionally add countries, agencies, notice types, references, or deadline ranges.
4. Choose whether to include detail pages.
5. Set `maxItems` to the number of notices you need.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Input options

#### Search filters

- `keyword` — searches tender titles.
- `reference` — searches a specific reference number.
- `description` — searches notice description text.
- `countries` — filters beneficiary countries or territories.
- `agencies` — filters UN agencies when you know UNGM values.
- `noticeTypes` — filters opportunity types.
- `unspscs` — filters category or UNSPSC values.

#### Date filters

- `publishedFrom`
- `publishedTo`
- `deadlineFrom`
- `deadlineTo`

Dates can be entered as `YYYY-MM-DD` or UNGM-style `DD-MMM-YYYY`.

#### Run options

- `activeOnly` — return active/open notices only.
- `sustainableOnly` — return sustainable-procurement notices only.
- `includeDetails` — fetch detail pages for documents, contacts, links, and descriptions.
- `maxItems` — maximum number of notices to save.
- `pageSize` — search results requested per page (UNGM returns up to 15 rows per page).
- `sortField` — deadline, publication date, title, or reference.
- `sortAscending` — choose sort direction.

### Example input

```json
{
  "keyword": "medical",
  "activeOnly": true,
  "includeDetails": true,
  "maxItems": 50,
  "pageSize": 15,
  "sortField": "Deadline",
  "sortAscending": true
}
````

### Example output

```json
{
  "noticeId": "300903",
  "title": "Lot 1: WIPO/UPOV Group Medical Insurance Plan (GMIP)",
  "agency": "WIPO",
  "noticeType": "Request for proposal",
  "reference": "rfx_771",
  "countries": ["Switzerland"],
  "publishedDate": "13-May-2026",
  "deadline": "03-Jul-2026 16:00 (GMT 2.00)",
  "detailUrl": "https://www.ungm.org/Public/Notice/300903",
  "description": "This is a Request for Proposals...",
  "documentLinks": [
    {
      "name": "WIPO eSourcing user guide for suppliers.pdf",
      "url": "https://www.ungm.org/Public/Notice/DownloadDocument?noticeId=300903&documentId=2018912"
    }
  ],
  "scrapedAt": "2026-07-03T02:32:53.177Z"
}
```

### Tips for better UNGM tender extraction

- Use `includeDetails: true` when you need documents, contacts, and long descriptions.
- Use `includeDetails: false` for faster monitoring where title, agency, country, and deadline are enough.
- Keep searches narrow when scheduling daily runs.
- Use deadline windows for urgent opportunity monitoring.
- Use reference search when you already know the tender number.

### Integrations

You can connect the dataset to:

- Google Sheets for bid-pipeline review
- Slack or email alerts for new tenders
- Airtable or Notion procurement trackers
- CRM systems for supplier opportunity management
- Data warehouses for procurement-intelligence dashboards
- Apify webhooks for scheduled monitoring

### 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/ungm-tender-notices-scraper').call({
  keyword: 'medical supplies',
  activeOnly: true,
  includeDetails: true,
  maxItems: 25
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/ungm-tender-notices-scraper').call(run_input={
    'keyword': 'medical supplies',
    'activeOnly': True,
    'includeDetails': True,
    'maxItems': 25,
})

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~ungm-tender-notices-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keyword":"medical supplies","activeOnly":true,"includeDetails":true,"maxItems":25}'
```

### MCP integration

Use this actor from Claude Desktop, Claude Code, or other MCP-compatible tools through the Apify MCP server.

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/ungm-tender-notices-scraper
```

Add it in Claude Code:

```bash
claude mcp add apify-ungm-tenders https://mcp.apify.com/?tools=automation-lab/ungm-tender-notices-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-ungm-tenders": {
      "url": "https://mcp.apify.com/?tools=automation-lab/ungm-tender-notices-scraper"
    }
  }
}
```

Example prompts:

- "Find active UNGM medical supply tenders in West Africa and summarize upcoming deadlines."
- "Extract UNGM opportunities from UNICEF and WHO with document links."
- "Monitor UNGM tenders mentioning vehicles and create a bid triage table."

### Scheduling tender monitoring

Create an Apify schedule to run the scraper daily or weekly. Use narrow filters and a manageable `maxItems` value so each run returns actionable opportunities instead of a large undifferentiated export.

### Data quality notes

The actor extracts what is publicly available on UNGM at run time. Some notices have documents and contacts, while others only expose basic search-result fields.

UNGM may use country, agency, notice-type, and category values that must match its internal filters. If a filter returns no results, try a broader keyword search first.

### Troubleshooting

#### Why did my run return no items?

Your filters may be too narrow, the date window may exclude active opportunities, or the UNGM filter value may not match the site's exact value. Try removing country, agency, notice type, and date filters, then add them back one by one.

#### Why are document links missing?

Set `includeDetails` to `true`. Some notices still may not publish documents or may use external supplier portal links instead.

#### Why is the run slower with details enabled?

Detail mode visits each public notice page to collect descriptions, documents, contacts, links, and UNSPSC data. Disable it when you only need search-result monitoring.

### Legality

The actor collects publicly accessible procurement notices from UNGM. You should use the data responsibly, respect UNGM's terms and applicable laws, and avoid excessive run frequency. The actor does not bypass login-only features such as saving notices or submitting expressions of interest.

### FAQ

#### Is it legal to scrape UNGM notices?

This actor is designed for public procurement-monitoring workflows and does not bypass login-only UNGM features. Always review your own use case for compliance with applicable rules.

#### Can I download every bid document automatically?

The dataset includes public document links where UNGM exposes them. Downloading large document batches should be done responsibly and only when needed for your procurement workflow.

### Related scrapers

Explore related automation-lab procurement and public-sector actors:

- https://apify.com/automation-lab/contracts-finder-scraper
- https://apify.com/automation-lab/uk-find-a-tender-scraper

### Support

If you need a new field, a specific UNGM filter, or help integrating tender notices into a monitoring workflow, open an issue on the actor page.

# Actor input Schema

## `keyword` (type: `string`):

Search phrase matched against UNGM notice titles, for example medical supplies, vehicles, construction, or consultancy.

## `reference` (type: `string`):

Optional UNGM or agency reference number to search for an exact opportunity.

## `description` (type: `string`):

Optional text to search in the notice description.

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

UNGM country or territory filters. Use names as they appear on UNGM, e.g. Mali, Kenya, Ukraine.

## `agencies` (type: `array`):

Agency filters such as UNDP, UNICEF, IOM, UNOPS, WHO. Leave empty for all agencies.

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

Opportunity types such as Invitation to bid, Request for proposal, Request for quotation, or Request for EOI.

## `unspscs` (type: `array`):

UNSPSC category filters if you know the UNGM values to submit.

## `publishedFrom` (type: `string`):

Earliest publication date. Use YYYY-MM-DD or UNGM format DD-MMM-YYYY.

## `publishedTo` (type: `string`):

Latest publication date. Use YYYY-MM-DD or UNGM format DD-MMM-YYYY.

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

Earliest tender deadline. Use YYYY-MM-DD or UNGM format DD-MMM-YYYY.

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

Latest tender deadline. Use YYYY-MM-DD or UNGM format DD-MMM-YYYY.

## `activeOnly` (type: `boolean`):

Return only procurement opportunities that UNGM marks as active/open.

## `sustainableOnly` (type: `boolean`):

Limit results to notices tagged as sustainable procurement by UNGM.

## `includeDetails` (type: `boolean`):

Fetch each notice detail page to include long descriptions, documents, external links, contacts, and UNSPSC data. Slower but richer.

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

Maximum number of UNGM tender notices to save.

## `pageSize` (type: `integer`):

Number of notices requested from UNGM per search page. UNGM returns up to 15 rows per page.

## `sortField` (type: `string`):

UNGM search sort field.

## `sortAscending` (type: `boolean`):

Sort ascending instead of descending.

## Actor input object example

```json
{
  "keyword": "medical",
  "activeOnly": true,
  "sustainableOnly": false,
  "includeDetails": true,
  "maxItems": 20,
  "pageSize": 15,
  "sortField": "Deadline",
  "sortAscending": true
}
```

# 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 = {
    "keyword": "medical",
    "activeOnly": true,
    "sustainableOnly": false,
    "includeDetails": true,
    "maxItems": 20,
    "pageSize": 15,
    "sortField": "Deadline",
    "sortAscending": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ungm-tender-notices-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 = {
    "keyword": "medical",
    "activeOnly": True,
    "sustainableOnly": False,
    "includeDetails": True,
    "maxItems": 20,
    "pageSize": 15,
    "sortField": "Deadline",
    "sortAscending": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ungm-tender-notices-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 '{
  "keyword": "medical",
  "activeOnly": true,
  "sustainableOnly": false,
  "includeDetails": true,
  "maxItems": 20,
  "pageSize": 15,
  "sortField": "Deadline",
  "sortAscending": true
}' |
apify call automation-lab/ungm-tender-notices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UNGM Tender Notices Scraper",
        "description": "Scrape public UNGM procurement notices with agencies, countries, deadlines, documents, contacts, and tender detail links.",
        "version": "0.1",
        "x-build-id": "x6LMbDH5A1ALhS6C5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ungm-tender-notices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ungm-tender-notices-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~ungm-tender-notices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ungm-tender-notices-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~ungm-tender-notices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ungm-tender-notices-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": {
                    "keyword": {
                        "title": "Keyword / tender title",
                        "type": "string",
                        "description": "Search phrase matched against UNGM notice titles, for example medical supplies, vehicles, construction, or consultancy."
                    },
                    "reference": {
                        "title": "Reference number",
                        "type": "string",
                        "description": "Optional UNGM or agency reference number to search for an exact opportunity."
                    },
                    "description": {
                        "title": "Description contains",
                        "type": "string",
                        "description": "Optional text to search in the notice description."
                    },
                    "countries": {
                        "title": "Beneficiary countries / territories",
                        "type": "array",
                        "description": "UNGM country or territory filters. Use names as they appear on UNGM, e.g. Mali, Kenya, Ukraine.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "agencies": {
                        "title": "UN agencies",
                        "type": "array",
                        "description": "Agency filters such as UNDP, UNICEF, IOM, UNOPS, WHO. Leave empty for all agencies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "noticeTypes": {
                        "title": "Notice types",
                        "type": "array",
                        "description": "Opportunity types such as Invitation to bid, Request for proposal, Request for quotation, or Request for EOI.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "unspscs": {
                        "title": "UNSPSC codes or categories",
                        "type": "array",
                        "description": "UNSPSC category filters if you know the UNGM values to submit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "publishedFrom": {
                        "title": "Published from",
                        "type": "string",
                        "description": "Earliest publication date. Use YYYY-MM-DD or UNGM format DD-MMM-YYYY."
                    },
                    "publishedTo": {
                        "title": "Published to",
                        "type": "string",
                        "description": "Latest publication date. Use YYYY-MM-DD or UNGM format DD-MMM-YYYY."
                    },
                    "deadlineFrom": {
                        "title": "Deadline from",
                        "type": "string",
                        "description": "Earliest tender deadline. Use YYYY-MM-DD or UNGM format DD-MMM-YYYY."
                    },
                    "deadlineTo": {
                        "title": "Deadline to",
                        "type": "string",
                        "description": "Latest tender deadline. Use YYYY-MM-DD or UNGM format DD-MMM-YYYY."
                    },
                    "activeOnly": {
                        "title": "Active notices only",
                        "type": "boolean",
                        "description": "Return only procurement opportunities that UNGM marks as active/open.",
                        "default": true
                    },
                    "sustainableOnly": {
                        "title": "Sustainable procurement only",
                        "type": "boolean",
                        "description": "Limit results to notices tagged as sustainable procurement by UNGM.",
                        "default": false
                    },
                    "includeDetails": {
                        "title": "Include detail pages",
                        "type": "boolean",
                        "description": "Fetch each notice detail page to include long descriptions, documents, external links, contacts, and UNSPSC data. Slower but richer.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum notices",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of UNGM tender notices to save.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Search page size",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Number of notices requested from UNGM per search page. UNGM returns up to 15 rows per page.",
                        "default": 15
                    },
                    "sortField": {
                        "title": "Sort field",
                        "enum": [
                            "Deadline",
                            "DatePublished",
                            "Title",
                            "Reference"
                        ],
                        "type": "string",
                        "description": "UNGM search sort field.",
                        "default": "Deadline"
                    },
                    "sortAscending": {
                        "title": "Sort ascending",
                        "type": "boolean",
                        "description": "Sort ascending instead of descending.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
