# Forex Factory Economic Calendar Scraper (`automation-lab/forex-factory-economic-calendar-scraper`) Actor

📅 Export current-week Forex Factory macro events with stable IDs, currency, impact, forecast, previous value, local schedule, and canonical URLs. Filter records for trading-risk dashboards, alerts, and market-data pipelines.

- **URL**: https://apify.com/automation-lab/forex-factory-economic-calendar-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/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

## Forex Factory Economic Calendar Scraper

Export the **current-week Forex Factory economic calendar** as clean JSON, CSV, Excel, XML, or RSS-ready dataset records.

Get event titles, currencies, local dates and times, impact levels, forecasts, previous values, stable IDs, and canonical Forex Factory URLs without a login or API key.

This Actor is designed for repeat schedules: trading-risk dashboards, market alerts, quantitative pipelines, newsletters, and research notebooks can refresh the same structured contract throughout the week.

> The source feed does not declare a timezone. This Actor preserves the source-local schedule and never invents a UTC instant.

### What does Forex Factory Economic Calendar Scraper do?

The Actor fetches Forex Factory's public current-week structured feed and turns every valid macroeconomic event into a normalized dataset row.

It can:

- 📅 extract this week's economic calendar events;
- 💱 select currencies such as USD, EUR, GBP, JPY, CAD, AUD, NZD, or CHF;
- 🚨 select High, Medium, Low, or Holiday impact levels;
- 🔎 restrict results to an inclusive local-date window;
- 🧩 create a deterministic event ID for deduplication;
- 🔗 preserve the canonical Forex Factory event URL;
- 📤 export results through Apify datasets and integrations.

The minimum product intentionally stays on the proven public current-week feed. It does not claim arbitrary historical coverage.

### Who is it for?

#### Traders and risk managers

Build a weekly risk calendar before entering positions. Filter to High-impact USD or EUR releases and send the records to an alerting tool.

#### Quantitative and market-data teams

Load normalized event schedules into a warehouse, join them to price series, and use stable IDs to avoid duplicate processing.

#### Newsletters and research desks

Create a repeatable list of upcoming macro events, forecasts, and previous values for briefing documents.

#### Automation builders

Run the Actor on a schedule and connect the dataset to Slack, Google Sheets, webhooks, Make, Zapier, or custom code.

### Why use this economic calendar extractor?

Forex Factory presents useful macroeconomic information, but automation needs a stable machine-readable contract.

This Actor adds:

- **normalized dates** in `YYYY-MM-DD` format;
- **normalized clock times** in 24-hour format when available;
- **safe timezone handling** with `timezone: null` when the feed is silent;
- **null preservation** for blank forecasts and previous values;
- **stable IDs** derived from event identity fields;
- **bounded retries and validation** instead of silent empty output;
- **pay-per-event billing** aligned with produced data.

### What data can I extract?

| Field | Type | Description |
|---|---|---|
| `eventId` | string | Stable 24-character event identifier |
| `title` | string | Economic event title |
| `currency` | string | Three-letter affected currency code |
| `localDate` | string | Source-local date in `YYYY-MM-DD` |
| `localTime` | string | 24-hour time, `All Day`, `Tentative`, or `Unscheduled` |
| `localDateTime` | string or null | Timezone-free local datetime when a clock time exists |
| `timezone` | null | Explicit null because the XML feed declares no timezone |
| `impact` | string | High, Medium, Low, or Holiday |
| `forecast` | string or null | Forecast value exactly as supplied |
| `previous` | string or null | Previous value exactly as supplied |
| `url` | string | Canonical Forex Factory calendar URL |
| `source` | string | `Forex Factory` |
| `scrapedAt` | string | UTC extraction timestamp |

### How to scrape the Forex Factory calendar

1. Open the Actor input page.
2. Set **Maximum events** to the number you need.
3. Optionally add currency codes such as `USD` and `EUR`.
4. Optionally select impact levels such as `High`.
5. Optionally enter `dateFrom` and `dateTo` using `YYYY-MM-DD`.
6. Click **Start**.
7. Open the dataset to preview or export the economic events.
8. Add a schedule if you need recurring refreshes.

The default input is deliberately small enough for a fast first run.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `maxItems` | integer | 100 | Maximum matching events to save, from 1 to 500 |
| `currencies` | string[] | `[]` | Optional three-letter currency filters |
| `impacts` | string[] | `[]` | Optional High, Medium, Low, or Holiday filters |
| `dateFrom` | string | unset | Inclusive source-local start date |
| `dateTo` | string | unset | Inclusive source-local end date |

Empty filter arrays include all source values. Currency matching is case-insensitive.

Invalid date formats, invalid currency codes, reversed date ranges, and unsupported impact values fail closed.

### Example input: high-impact USD events

```json
{
  "currencies": ["USD"],
  "impacts": ["High"],
  "maxItems": 50
}
````

For a broad weekly export:

```json
{
  "maxItems": 100
}
```

For a major-currency risk monitor:

```json
{
  "currencies": ["USD", "EUR", "GBP", "JPY"],
  "impacts": ["High", "Medium"],
  "maxItems": 200
}
```

### Example output

```json
{
  "eventId": "37d74dd9479b359e70134b18",
  "title": "BusinessNZ Services Index",
  "currency": "NZD",
  "localDate": "2026-07-12",
  "localTime": "22:30",
  "localDateTime": "2026-07-12T22:30:00",
  "timezone": null,
  "impact": "Low",
  "forecast": null,
  "previous": "47.5",
  "url": "https://www.forexfactory.com/calendar/852-nz-businessnz-services-index",
  "source": "Forex Factory",
  "scrapedAt": "2026-07-16T02:30:00.000Z"
}
```

Values such as percentages or abbreviations remain strings because the source may include units and revisions.

### Local time and timezone semantics

The public current-week export provides a date and time but does not declare an IANA timezone or UTC offset in the complete CSV/XML record.

Accordingly:

- `localDate` preserves the calendar date;
- `localTime` normalizes ordinary clock times to 24-hour form;
- `localDateTime` combines those values without a timezone suffix;
- `timezone` is always `null`;
- all-day or tentative events have `localDateTime: null`.

Consumers should apply a timezone only when they have an independently verified source rule. This avoids shifting releases to the wrong instant.

### Stable IDs and scheduled monitoring

The `eventId` is derived from title, currency, date, time, and canonical URL.

For scheduled workflows:

1. store the latest dataset in your database;
2. use `eventId` as a natural deduplication key;
3. compare forecasts or previous values when the same ID reappears;
4. alert only when a record is new or changed.

IDs are stable for unchanged source records, but a corrected source schedule can intentionally produce a new ID.

### How much does it cost to scrape Forex Factory events?

The Actor uses pay-per-event pricing. A run costs **$0.005** to start, then one item event per saved economic event.

| Apify tier | Price per saved event | 100 events plus start |
|---|---:|---:|
| Free | $0.000042972 | about $0.00930 |
| Bronze | $0.000037367 | about $0.00874 |
| Silver | $0.000029146 | about $0.00791 |
| Gold | $0.000022420 | about $0.00724 |
| Platinum | $0.000014947 | about $0.00649 |
| Diamond | $0.000010463 | about $0.00605 |

Input filters and `maxItems` let you cap output and spending. A run that saves 20 events charges one start event and 20 item events. Filtered-out source records are not item-charged.

### Tips for reliable calendar workflows

- 🗓️ Run on a schedule appropriate for your dashboard, not every minute by default.
- 🚨 Use impact filters when only market-moving releases matter.
- 💱 Use uppercase ISO-style codes in documentation, although input matching is case-insensitive.
- 🔑 Deduplicate on `eventId`, not title alone.
- 🕐 Treat local schedule fields as timezone-free unless you verify the source convention.
- 📦 Export the dataset after each run or consume it through the API.
- 🔍 Preserve null forecasts; a blank value is different from zero.

### Integrations and automation patterns

#### Google Sheets briefing

Schedule the Actor before a weekly trading meeting and export the dataset to a Sheet sorted by local date and impact.

#### Slack or email risk alerts

Filter to High-impact currencies, compare IDs against the prior run, and post new events to a risk channel.

#### Data warehouse ingestion

Use a webhook to copy completed dataset rows into BigQuery, Snowflake, PostgreSQL, or another warehouse.

#### Market-research notebook

Fetch dataset JSON in Python and join local event schedules to independently timezone-normalized market data.

#### Make and Zapier

Trigger a run on a schedule, iterate dataset rows, and route events by currency or impact.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/forex-factory-economic-calendar-scraper').call({
  currencies: ['USD', 'EUR'],
  impacts: ['High'],
  maxItems: 50,
});

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

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/forex-factory-economic-calendar-scraper').call(
    run_input={
        'currencies': ['USD', 'EUR'],
        'impacts': ['High'],
        'maxItems': 50,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~forex-factory-economic-calendar-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"currencies":["USD"],"impacts":["High"],"maxItems":50}'
```

After the run succeeds, read its `defaultDatasetId` and request `/v2/datasets/{DATASET_ID}/items`.

### Use with Apify MCP

Connect Claude Code with:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/forex-factory-economic-calendar-scraper"
```

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/forex-factory-economic-calendar-scraper"
    }
  }
}
```

Example prompts:

- “Extract this week's high-impact USD Forex Factory events.”
- “Build a JSON list of medium- and high-impact EUR and GBP releases.”
- “Compare these event IDs with yesterday's dataset and summarize changes.”

### Source coverage and limitations

The Actor covers the current public weekly feed available at run time.

It does not:

- crawl arbitrary historical date ranges;
- predict future values;
- provide trading advice;
- invent missing forecast or previous values;
- convert local schedules to UTC without source timezone evidence;
- scrape private account data.

The upstream feed can revise event dates, times, values, or URLs. Scheduled users should treat each run as a fresh source snapshot.

### Data quality and error handling

The extractor validates required titles, dates, currency codes, impact levels, and canonical event URLs.

Individual malformed records are skipped with warning logs. A missing feed root or a feed with no parseable events fails rather than returning a misleading empty success.

Requests use a finite timeout and bounded retries. The actor explicitly decodes the feed's declared Windows-1252 encoding.

### Legality: is scraping Forex Factory legal?

This Actor reads an anonymously accessible public structured feed and does not bypass login controls.

You are responsible for your use of the data, including compliance with applicable laws, contracts, Forex Factory terms, intellectual-property rights, and privacy obligations.

Use reasonable schedules, avoid unnecessary load, and do not present the output as investment advice.

### FAQ

#### Does the Actor need a Forex Factory account?

No. The current-week feed used by this Actor is publicly accessible without a login or API key.

#### Can I scrape last month or any custom historical range?

Not in v1. The reliable product scope is the public current-week feed. Date filters narrow that feed; they do not request historical pages.

#### Why is `timezone` null?

The complete CSV/XML record does not declare a timezone. Returning null is safer than inventing an offset that could move an event to the wrong instant.

#### Why are some forecasts or previous values null?

Forex Factory leaves some values blank, especially before estimates are available. The Actor preserves blanks as null rather than treating them as zero.

#### Why did my filtered run return no events?

The selected currencies, impacts, or local date range may not occur in the current weekly feed. Remove filters or inspect the unfiltered weekly export.

#### Why did the run reject my date?

Use `YYYY-MM-DD`, for example `2026-07-16`. Ensure `dateFrom` is not later than `dateTo`.

#### Can I stop after a fixed number of records?

Yes. Set `maxItems` from 1 to 500. It applies after filtering.

#### Can I use the output for automated trading?

You can integrate it into your own systems, but verify timing and data independently. The Actor is a data extraction tool, not financial advice.

### Related scrapers

Combine this Actor with other automation-lab data tools:

- [Trading Economics Indicators Scraper](https://apify.com/automation-lab/trading-economics-indicators-scraper) for broader indicator datasets.
- [SEC 8-K Current Reports Scraper](https://apify.com/automation-lab/sec-8-k-current-reports-scraper) for market-moving company filings.
- [US Treasury Fiscal Data Scraper](https://apify.com/automation-lab/us-treasury-fiscal-data-scraper) for official fiscal series.

Choose this Actor when your workflow specifically needs the Forex Factory current-week event feed.

### Support

If a run fails unexpectedly, share the run URL and a minimal input that reproduces the issue through the Actor page.

Useful details include:

- the currency and impact filters used;
- the local date range;
- whether an unfiltered run worked;
- the expected event title or URL.

These details make source-feed changes and parser regressions faster to diagnose.

# Actor input Schema

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

Stop after this many matching Forex Factory events. Use a small value for quick tests.

## `currencies` (type: `array`):

Only save events for these three-letter currency codes, such as USD, EUR, GBP, or JPY.

## `impacts` (type: `array`):

Only save events at the selected Forex Factory impact levels.

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

Include events on or after this source-local date (YYYY-MM-DD). The feed does not declare a timezone.

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

Include events on or before this source-local date (YYYY-MM-DD). The feed does not declare a timezone.

## Actor input object example

```json
{
  "maxItems": 10,
  "currencies": [],
  "impacts": []
}
```

# 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 = {
    "maxItems": 10,
    "currencies": [],
    "impacts": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/forex-factory-economic-calendar-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 = {
    "maxItems": 10,
    "currencies": [],
    "impacts": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/forex-factory-economic-calendar-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 '{
  "maxItems": 10,
  "currencies": [],
  "impacts": []
}' |
apify call automation-lab/forex-factory-economic-calendar-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Forex Factory Economic Calendar Scraper",
        "description": "📅 Export current-week Forex Factory macro events with stable IDs, currency, impact, forecast, previous value, local schedule, and canonical URLs. Filter records for trading-risk dashboards, alerts, and market-data pipelines.",
        "version": "0.1",
        "x-build-id": "mxQwlZSV9WKPiKGJ4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~forex-factory-economic-calendar-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-forex-factory-economic-calendar-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~forex-factory-economic-calendar-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-forex-factory-economic-calendar-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~forex-factory-economic-calendar-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-forex-factory-economic-calendar-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": {
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after this many matching Forex Factory events. Use a small value for quick tests.",
                        "default": 100
                    },
                    "currencies": {
                        "title": "Currency codes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only save events for these three-letter currency codes, such as USD, EUR, GBP, or JPY.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{3}$"
                        },
                        "default": []
                    },
                    "impacts": {
                        "title": "Impact levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only save events at the selected Forex Factory impact levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "High",
                                "Medium",
                                "Low",
                                "Holiday"
                            ],
                            "enumTitles": [
                                "High impact",
                                "Medium impact",
                                "Low impact",
                                "Holiday"
                            ]
                        },
                        "default": []
                    },
                    "dateFrom": {
                        "title": "Local date from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Include events on or after this source-local date (YYYY-MM-DD). The feed does not declare a timezone."
                    },
                    "dateTo": {
                        "title": "Local date to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Include events on or before this source-local date (YYYY-MM-DD). The feed does not declare a timezone."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```