# GDELT Global News Search Scraper (`automation-lab/gdelt-global-news-search-scraper`) Actor

🌍 Search worldwide news with GDELT and export clean, deduplicated article metadata for media monitoring, research, alerts, and RAG pipelines.

- **URL**: https://apify.com/automation-lab/gdelt-global-news-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** News
- **Stats:** 3 total users, 2 monthly users, 71.4% 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## GDELT Global News Search Scraper

Search worldwide news coverage through the public GDELT DOC 2.0 index and export clean article records for monitoring, research, alerts, and data pipelines.

The Actor accepts ordinary keywords, quoted phrases, Boolean expressions, and supported GDELT query filters. It returns article titles, URLs, seen dates, source domains, languages, source countries, social images, and the query that found each article.

No GDELT account or API key is required.

### What does GDELT Global News Search Scraper do?

GDELT Global News Search Scraper turns one or more news searches into a reusable Apify dataset.

Use it to:

- 🔎 search recent worldwide news for a brand, person, place, product, or event;
- 📰 collect article links and source metadata without maintaining API code;
- 🌍 compare coverage across languages, countries, and publishers;
- ⏰ schedule recurring media-monitoring runs;
- 🧠 feed current article evidence into RAG, analysis, or alerting workflows;
- 📊 export the same records as JSON, CSV, Excel, XML, or RSS.

The Actor uses GDELT's public DOC 2.0 ArticleList JSON surface. It does not scrape publisher article bodies and does not claim access to paid GDELT Cloud data.

### Who is it for?

#### PR and communications teams

Track mentions of a company, executive, campaign, product launch, or crisis across international sources.

#### Journalists and researchers

Discover coverage around an event and retain source, date, country, and language provenance.

#### Risk and geopolitical analysts

Schedule searches for supply-chain disruptions, sanctions, conflict indicators, infrastructure incidents, or regulatory change.

#### Developers and data engineers

Create a stable news-search dataset for dashboards, alerts, enrichment, RAG retrieval, or downstream classification.

#### Competitive-intelligence teams

Monitor competitors, markets, leadership changes, partnerships, funding announcements, and product releases.

### Why use this Actor?

Calling a public endpoint once is easy. Operating repeat searches reliably is harder.

This Actor adds:

- ✅ validated Apify input with low-cost defaults;
- ✅ sequential requests that respect GDELT's shared public rate limit;
- ✅ bounded retry handling for throttling and temporary server errors;
- ✅ strict response and content-type validation;
- ✅ normalized, typed output records;
- ✅ duplicate removal by article URL across all queries;
- ✅ query provenance on every record;
- ✅ datasets, schedules, webhooks, API access, and integrations from Apify.

### What data can I extract?

| Field | Type | Description |
|---|---|---|
| `query` | string | The input query that produced the article. |
| `title` | string | Article headline returned by GDELT. |
| `url` | string | Public publisher URL. |
| `seendate` | string | GDELT's seen-date value. |
| `socialimage` | string, optional | Social preview image when available. |
| `domain` | string | Publisher/source domain. |
| `language` | string | Language label supplied by GDELT. |
| `sourcecountry` | string | Source-country label supplied by GDELT. |
| `scrapedAt` | string | UTC time when the Actor saved the record. |

A social image is not available for every article. Other source metadata may occasionally be an empty string when GDELT does not populate it.

### Input

The smallest valid input is:

```json
{
  "queries": ["climate change"]
}
````

A monitoring input with explicit options is:

```json
{
  "queries": [
    "\"shipping disruption\"",
    "energy infrastructure attack",
    "border closure"
  ],
  "maxResultsPerQuery": 100,
  "timespan": "7d",
  "sort": "DateDesc"
}
```

### Search query syntax

GDELT supports expressive queries.

Common patterns include:

- a keyword: `inflation`;
- an exact phrase: `"climate policy"`;
- alternatives: `earthquake OR tsunami`;
- combined terms: `semiconductor AND export`;
- a source domain: `artificial intelligence domain:reuters.com`.

Query syntax is interpreted by GDELT. Start with a simple expression, inspect the results, and then add filters.

### Time windows

Use `timespan` for a rolling window relative to the run time.

Examples:

- `15min` for the latest fifteen minutes;
- `24h` for the latest day;
- `7d` for the latest week;
- `2weeks` for the latest two weeks;
- `3months` for the latest three months.

For a precise range, use `startDateTime` and/or `endDateTime` in UTC `YYYYMMDDHHMMSS` format.

Do not combine a relative `timespan` with exact date-time fields.

### Sort options

Choose one of GDELT's supported ArticleList sort modes:

- `DateDesc` — newest first;
- `DateAsc` — oldest first;
- `ToneDesc` — more positive tone first;
- `ToneAsc` — more negative tone first;
- `HybridRel` — hybrid relevance order.

`DateDesc` is the default and is usually best for scheduled monitoring.

### Output example

```json
{
  "query": "climate change",
  "title": "Example headline returned by GDELT",
  "url": "https://example.com/news/example-story",
  "seendate": "20260717T120000Z",
  "socialimage": "https://example.com/images/story.jpg",
  "domain": "example.com",
  "language": "English",
  "sourcecountry": "United States",
  "scrapedAt": "2026-07-17T12:05:00.000Z"
}
```

The values above illustrate the schema. Actual values come directly from the live GDELT article index.

### How to run the scraper

1. Open the Actor input page.
2. Add one or more topics or GDELT query expressions.
3. Keep the result limit small for your first run.
4. Choose a rolling window or exact UTC date range.
5. Select the desired sort order.
6. Click **Start**.
7. Open the Dataset tab to preview or export articles.

For recurring monitoring, create an Apify schedule after confirming the query returns the coverage you expect.

### How much does it cost to search GDELT news?

The Actor uses pay-per-event pricing: every run has a **$0.005 run-start fee**, then each unique article saved to the dataset is charged at your plan's tiered rate. Malformed records and duplicate URLs are not saved or charged as articles.

| Apify plan tier | Price per saved article |
| --- | ---: |
| FREE | $0.0024185 |
| BRONZE | $0.002103 |
| SILVER | $0.0016404 |
| GOLD | $0.0012618 |
| PLATINUM | $0.00084122 |
| DIAMOND | $0.00058885 |

Each run also has a **$0.005 run-start fee**. The total actor charge is the start event plus the saved-article events at your plan's rate; confirm your current tier in the Apify pricing panel before starting a run.

### Deduplication behavior

Articles are deduplicated by their full URL across the entire run.

If the same URL matches multiple queries, the first matching query in your input is retained in `query` and the duplicate is skipped.

GDELT or publishers may expose semantically identical stories under different URLs. Those remain separate records because the Actor does not guess that distinct URLs are duplicates.

### Scheduling a news monitor

A typical monitoring workflow is:

1. create one focused query per topic or stakeholder;
2. use `DateDesc` with a short rolling window;
3. schedule the Actor at an interval appropriate for your team;
4. connect a webhook, Make, Zapier, Slack workflow, or database export;
5. filter or classify new dataset rows downstream.

GDELT's public endpoint is shared infrastructure. Avoid schedules that create unnecessary request volume.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to append article records to a collaborative tracker.

#### Slack or Microsoft Teams alerts

Trigger a webhook after a successful run and send selected headlines to an alert channel.

#### Make and Zapier

Start a run from an automation, retrieve dataset items, then route coverage to a CRM, email, or database.

#### Data warehouses

Fetch dataset items through the API and load them into BigQuery, Snowflake, PostgreSQL, or your object store.

#### RAG and AI pipelines

Use article metadata as discovery evidence, then retrieve publisher pages only when your downstream workflow is authorized to do so.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/gdelt-global-news-search-scraper').call({
  queries: ['"climate policy"'],
  maxResultsPerQuery: 25,
  timespan: '7d',
  sort: 'DateDesc',
});

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

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/gdelt-global-news-search-scraper').call(run_input={
    'queries': ['artificial intelligence domain:reuters.com'],
    'maxResultsPerQuery': 25,
    'timespan': '24h',
    'sort': 'DateDesc',
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### cURL API example

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~gdelt-global-news-search-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "queries": ["supply chain disruption"],
    "maxResultsPerQuery": 25,
    "timespan": "7d",
    "sort": "DateDesc"
  }'
```

After the run finishes, read items from its `defaultDatasetId`.

### Use with Apify MCP

Connect the Actor to Claude or another MCP client through Apify MCP.

#### Claude Code setup

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/gdelt-global-news-search-scraper'
```

#### Claude Desktop setup

Add this server to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/gdelt-global-news-search-scraper"
    }
  }
}
```

#### Cursor setup

Add the same `mcpServers` JSON to Cursor's MCP settings and restart the client.

#### VS Code setup

Open the MCP server settings in VS Code, add the Apify HTTP endpoint above, and enable it for your workspace.

Example prompts:

- “Run the GDELT news scraper for semiconductor export controls from the last seven days.”
- “Collect the newest coverage of shipping disruption and summarize sources by country.”
- “Create a dataset of Reuters AI coverage from the last 24 hours.”

### Reliability and rate limits

The public GDELT DOC API asks clients to leave at least five seconds between requests on shared infrastructure.

This Actor processes queries sequentially and waits at least six seconds between requests.

Temporary throttling, server errors, timeouts, unexpected content types, and malformed envelopes receive bounded retries.

A query that validly returns zero articles is considered successful. If every query fails at the extraction layer, the Actor fails instead of silently returning a misleading success.

### Limitations

- GDELT controls index coverage, ranking, metadata, and retention.
- ArticleList returns at most 250 records per query.
- The Actor does not paginate beyond that public ArticleList limit.
- The Actor returns article metadata, not full publisher article text.
- Some records do not include a social image or complete source metadata.
- Search results can change as GDELT updates its index.
- Publisher links may later move, redirect, or become unavailable.
- Exact-date searches are subject to the time range supported by GDELT.

### Tips for better results

- Put multi-word names in quotes when you need phrase matching.
- Use several focused queries instead of one ambiguous expression.
- Begin with 10–25 results before increasing the limit.
- Use a short rolling window for frequent schedules.
- Keep `DateDesc` for alerts and recent-coverage monitoring.
- Add GDELT-supported domain, language, or source-country filters to the query when needed.
- Review a sample dataset before automating downstream decisions.

### Is it legal to use GDELT news data?

This Actor accesses a public GDELT search endpoint and returns metadata plus publisher URLs.

You are responsible for your use of the data and for complying with GDELT terms, publisher terms, copyright rules, privacy laws, and regulations that apply to your jurisdiction and workflow.

Do not treat a search result as permission to republish a publisher's article body. Seek legal advice for high-risk or commercial redistribution use cases.

### Troubleshooting

#### My run returns no articles

Try a simpler query, a wider time window, or a larger result limit. Confirm the expression is supported by GDELT and remove overly restrictive filters.

#### My exact date range is rejected

Use UTC timestamps in `YYYYMMDDHHMMSS` format, ensure the start is not after the end, and stay within GDELT's supported search period.

#### One query failed but the run succeeded

The Actor isolates query failures. It keeps useful results when at least one query completes, and records failed-query details in the run log.

#### The run takes longer with several queries

This is expected. Queries are intentionally sequential to respect GDELT's public rate limit.

#### An article appears under only one query

URL deduplication keeps the first occurrence. Reorder the queries if a particular provenance label should win.

### FAQ

#### Does this Actor require a GDELT key?

No. It uses the anonymous public GDELT DOC 2.0 article-search endpoint.

#### Can I search multiple topics?

Yes. Supply up to ten queries in one run. Each saved record includes its originating query.

#### Can I retrieve more than 250 articles per query?

No. Version 1 intentionally follows the public ArticleList maximum and does not claim unsupported pagination.

#### Does it download full article content?

No. It exports GDELT article metadata and publisher links.

#### Are duplicate articles charged twice?

Not when they share the same URL in one run. Duplicate URLs are skipped before dataset storage and article charging.

#### Can an empty query result succeed?

Yes. A valid empty GDELT response is different from extraction failure.

#### Can I export to CSV or Excel?

Yes. Use the dataset export controls or Apify dataset API.

### Related Automation Labs actors

For broader search and enrichment workflows, consider:

- [Google News Scraper](https://apify.com/automation-lab/google-news-scraper) for Google News discovery workflows;
- [Google Search Scraper](https://apify.com/automation-lab/google-search-scraper) for general web search results;
- [Website Content Crawler](https://apify.com/automation-lab/website-content-crawler) when you are authorized to retrieve content from selected article URLs.

Choose this Actor when GDELT's worldwide news index, source metadata, and query language are the core requirement.

### Support

If a run behaves unexpectedly, open an issue from the Actor page and include:

- a safe copy of the input;
- the run URL or run ID;
- the query that behaved unexpectedly;
- the expected and actual result;
- whether the issue is repeatable.

Do not include secrets, private tokens, or confidential query data in a public report.

# Actor input Schema

## `queries` (type: `array`):

One to ten GDELT search expressions. Supports phrases in quotes and operators such as AND, OR, and domain:example.com.

## `maxResultsPerQuery` (type: `integer`):

Maximum articles requested for each query. The public GDELT API supports up to 250.

## `sort` (type: `string`):

Order returned by GDELT: newest/oldest, tone, or hybrid relevance.

## `timespan` (type: `string`):

Optional rolling window such as 15min, 24h, 7d, 2weeks, or 3months. Do not combine with exact dates.

## `startDateTime` (type: `string`):

Optional UTC timestamp in YYYYMMDDHHMMSS format. Use instead of a relative time window.

## `endDateTime` (type: `string`):

Optional UTC timestamp in YYYYMMDDHHMMSS format. Use instead of a relative time window.

## Actor input object example

```json
{
  "queries": [
    "climate change"
  ],
  "maxResultsPerQuery": 10,
  "sort": "DateDesc",
  "timespan": "7d"
}
```

# 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 = {
    "queries": [
        "climate change"
    ],
    "maxResultsPerQuery": 10,
    "sort": "DateDesc",
    "timespan": "7d"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/gdelt-global-news-search-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 = {
    "queries": ["climate change"],
    "maxResultsPerQuery": 10,
    "sort": "DateDesc",
    "timespan": "7d",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/gdelt-global-news-search-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 '{
  "queries": [
    "climate change"
  ],
  "maxResultsPerQuery": 10,
  "sort": "DateDesc",
  "timespan": "7d"
}' |
apify call automation-lab/gdelt-global-news-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GDELT Global News Search Scraper",
        "description": "🌍 Search worldwide news with GDELT and export clean, deduplicated article metadata for media monitoring, research, alerts, and RAG pipelines.",
        "version": "0.1",
        "x-build-id": "reshvTa0E9hULqHPG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~gdelt-global-news-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-gdelt-global-news-search-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~gdelt-global-news-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-gdelt-global-news-search-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~gdelt-global-news-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-gdelt-global-news-search-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "🔎 Search queries",
                        "minItems": 1,
                        "maxItems": 10,
                        "type": "array",
                        "description": "One to ten GDELT search expressions. Supports phrases in quotes and operators such as AND, OR, and domain:example.com.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 512
                        },
                        "default": [
                            "climate change"
                        ]
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum articles per query",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum articles requested for each query. The public GDELT API supports up to 250.",
                        "default": 25
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "DateDesc",
                            "DateAsc",
                            "ToneDesc",
                            "ToneAsc",
                            "HybridRel"
                        ],
                        "type": "string",
                        "description": "Order returned by GDELT: newest/oldest, tone, or hybrid relevance.",
                        "default": "DateDesc"
                    },
                    "timespan": {
                        "title": "Relative time window",
                        "pattern": "^(?:1[5-9]|[2-9]\\d|\\d{3,})min$|^\\d+(?:h|hours|d|days|w|weeks|m|months)$",
                        "type": "string",
                        "description": "Optional rolling window such as 15min, 24h, 7d, 2weeks, or 3months. Do not combine with exact dates."
                    },
                    "startDateTime": {
                        "title": "Exact start time (UTC)",
                        "pattern": "^\\d{14}$",
                        "type": "string",
                        "description": "Optional UTC timestamp in YYYYMMDDHHMMSS format. Use instead of a relative time window."
                    },
                    "endDateTime": {
                        "title": "Exact end time (UTC)",
                        "pattern": "^\\d{14}$",
                        "type": "string",
                        "description": "Optional UTC timestamp in YYYYMMDDHHMMSS format. Use instead of a relative time window."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```