# ForexFactory Economic Calendar Scraper (No Login) (`scrapemint/forexfactory-economic-calendar`) Actor

Pull the public ForexFactory economic calendar by date range. Returns event date, time, currency, impact rating (high/med/low), title, actual, forecast, previous, revised values, and source. JSON. No login. Pay per event.

- **URL**: https://apify.com/scrapemint/forexfactory-economic-calendar.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Business, Marketing, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## ForexFactory Economic Calendar Scraper (No Login Required)

Pull the public ForexFactory economic calendar by any date range. No cookies. No login. No ForexFactory account. Each row ships the event date and UTC timestamp, currency, impact rating (high, medium, low, holiday), event title, actual release, market forecast (consensus), previous reading, revised previous, unit, source agency, and the link to the event detail page. Pay per event.

**Built for** FX traders pricing in NFP and CPI prints, equity desks tracking earnings season alongside macro releases, fixed income analysts modelling rate decisions, fintech newsletter writers shipping a daily macro brief, sentiment quants joining release surprises to candle moves, and crypto desks watching FOMC and SPR data for risk regime shifts.

**Keywords this actor ranks for:** forex factory scraper, economic calendar api, forex calendar api, nfp scraper, cpi release scraper, fomc calendar, macro events api, central bank calendar, economic data api, forecasting calendar.

---

### Why this actor

| Other econ calendar APIs | **This actor** |
|---|---|
| Charge $49 to $499 a month for the same public data | Charge per event row, no contract |
| Lock historical revisions behind a higher tier | Revised previous value on every row by default |
| Return one HTML blob per day | Date, time UTC, currency, impact, actual, forecast, previous, revised parsed |
| Drop the source agency tag | Source agency (BLS, ECB, BOE, BOJ, etc.) embedded on every row |
| Get rate limited at five rows | Built on residential proxy with session pooling for sustained runs |

---

### How it works

```mermaid
flowchart LR
    A[Date range or preset] --> B[Build calendar URL<br/>set timezone to UTC]
    B --> C[Open the public calendar<br/>no auth needed]
    C --> D[Walk day-breaker rows<br/>track current date]
    D --> E[Parse impact, currency, time<br/>actual, forecast, previous]
    E --> F[Optional fetch event detail<br/>description, source, frequency]
    F --> G[Push one row per event]
    G --> H[(JSON CSV Excel API)]
````

The actor sets ForexFactory's display timezone cookie to UTC before extraction so every event row carries a clean ISO 8601 timestamp. Day breaker rows in the calendar table set the current date as we iterate. Impact ratings come from the row's `impact--high`, `impact--medium`, `impact--low`, or `impact--holiday` class so they survive cosmetic redesigns.

***

### What you get per row

```mermaid
flowchart LR
    R[Event row] --> R1[Identity<br/>eventId url title]
    R --> R2[Schedule<br/>date time timestamp currency impact]
    R --> R3[Numbers<br/>actual forecast previous revised unit]
    R --> R4[Context<br/>source frequency description]
```

Pipe straight into a release surprise dashboard, a candle move attribution sheet, or a daily macro brief.

***

### Quick start

**Pull this week's high and medium impact USD events**

```json
{
  "range": "this_week",
  "currencies": ["USD"],
  "impactLevels": ["high", "medium"]
}
```

**Sweep next month for all G7 currencies**

```json
{
  "range": "next_month",
  "currencies": ["USD", "EUR", "GBP", "JPY", "CAD", "AUD", "CHF"],
  "impactLevels": ["high", "medium"]
}
```

**Custom range with full event detail**

```json
{
  "range": "custom",
  "startDate": "2026-05-01",
  "endDate": "2026-05-31",
  "impactLevels": ["high"],
  "includeDetail": true
}
```

***

### Sample output

```json
{
  "eventId": "20260509-USD-non-farm-employment-change",
  "url": "https://www.forexfactory.com/calendar?day=may9.2026#detail=143829",
  "date": "2026-05-09",
  "time": "08:30",
  "timestamp": "2026-05-09T08:30:00",
  "displayTimezone": "America/New_York",
  "currency": "USD",
  "impact": "high",
  "title": "Non-Farm Employment Change",
  "actual": "175K",
  "actualNumeric": 175000,
  "forecast": "200K",
  "forecastNumeric": 200000,
  "previous": "236K",
  "previousNumeric": 236000,
  "revised": "228K",
  "revisedNumeric": 228000,
  "unit": "K",
  "source": "Bureau of Labor Statistics",
  "frequency": "Released monthly",
  "description": "Change in the number of employed people during the previous month, excluding the farming industry...",
  "isAllDay": false,
  "scrapedAt": "2026-05-10T09:30:00.000Z"
}
```

***

### Who uses this

| Role | Use case |
|---|---|
| FX trader | Price in NFP, CPI, FOMC ahead of the release window |
| Equity desk | Track macro alongside earnings season for cross-asset signals |
| Fixed income analyst | Model rate decisions, GDP, inflation prints across central banks |
| Macro newsletter | Ship a daily brief of high impact events with forecasts |
| Sentiment quant | Join release surprise versus consensus to subsequent candle moves |
| Crypto desk | Watch FOMC and SPR releases for risk regime shifts |
| Algo dev | Avoid running a strategy through high impact event windows |

***

### Input reference

| Field | Type | What it does |
|---|---|---|
| `range` | string | today, tomorrow, yesterday, this\_week, next\_week, last\_week, this\_month, next\_month, custom. |
| `startDate` | string | YYYY-MM-DD. Required when range is custom. |
| `endDate` | string | YYYY-MM-DD. Required when range is custom. Max span 30 days. |
| `currencies` | string\[] | ISO codes to include. Empty pulls every currency. |
| `impactLevels` | string\[] | high, medium, low, holiday. Default high+medium. |
| `includeDetail` | boolean | Fetch each event's detail page for description, source, frequency. Default false. |
| `maxEvents` | integer | Stop after this many event rows. Default 1000. |
| `concurrency` | integer | Pages processed in parallel. Three is the safe default. |
| `proxyConfiguration` | object | Apify proxy. Residential required at any meaningful volume. |

***

### API call

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/YOUR_USER~forexfactory-economic-calendar/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "range": "this_week",
    "currencies": ["USD", "EUR"],
    "impactLevels": ["high"]
  }'
```

***

### Pricing

The first 25 event rows per run are free so you can validate output before paying. After that, each event row is charged. No surprise add on charges.

***

### FAQ

#### What timezone are the times in?

The `time` and `timestamp` fields use ForexFactory's display timezone, which defaults to America/New\_York (Eastern Time) for unauthenticated visitors. The exact zone in effect is returned on every row as `displayTimezone`. Convert downstream with the IANA zone string and a date library if your pipeline needs UTC.

#### How accurate is the actual value?

The actual is parsed in real time from the calendar page the moment the actor runs. If you run the actor before a release, actual will be null until ForexFactory publishes the print.

#### What does revised mean?

When a release agency revises the prior period's number after the fact, ForexFactory shows both the original previous value and the revised value. The actor returns both as `previous` and `revised`.

#### Can I pull a year of history?

Yes, but split it into monthly windows. The actor caps a single custom range at 30 days to keep request latency predictable. Schedule sequential runs per month and concatenate the dataset.

#### What about all-day events like bank holidays?

The actor sets `isAllDay: true` and leaves `time` and `timestamp` null for events that ForexFactory marks as all day or tentative.

#### How fresh is the data?

Each run hits the live calendar page, so actual values reflect what ForexFactory shows at scrape time. Schedule a run every 30 minutes during high impact event windows for near-live release tracking.

#### Is scraping ForexFactory allowed?

This actor reads HTML any anonymous web visitor can see. Respect ForexFactory's terms and rate limit sensibly. Do not redistribute personal data you have no lawful basis to process.

***

### Related actors

- **TradingView Ideas Scraper** — pull public trade ideas with author, direction, timeframe, and engagement
- **Polymarket Scraper** — pull live prediction market odds, volume, and resolution metadata
- **Sports Odds Scraper** — pull live moneyline, spread, and total odds across sportsbooks
- **Crypto Whale Token Launch Tracker** — pull on-chain whale wallet activity around new launches
- **Google Patents Scraper** — pull patent metadata, claims, and citations by query

# Actor input Schema

## `range` (type: `string`):

Preset date window. Choose 'custom' to use startDate and endDate.

## `startDate` (type: `string`):

First date to pull, inclusive. Required when range is 'custom'. Format YYYY-MM-DD.

## `endDate` (type: `string`):

Last date to pull, inclusive. Required when range is 'custom'. Max 30 days span. Format YYYY-MM-DD.

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

ISO currency codes to include. Empty pulls every currency on the calendar.

## `impactLevels` (type: `array`):

Impact ratings to include. Default keeps high and medium only. Add 'low' or 'holiday' to widen.

## `includeDetail` (type: `boolean`):

Fetch each event's detail page for description, source agency, frequency, and revision history. Adds one extra request per event.

## `maxEvents` (type: `integer`):

Stop after this many event rows. Default 1000 covers a full month of high+medium events.

## `concurrency` (type: `integer`):

Number of pages processed in parallel. Three is a safe default for ForexFactory.

## `proxyConfiguration` (type: `object`):

Apify proxy. Residential is required at any meaningful volume.

## Actor input object example

```json
{
  "range": "this_week",
  "startDate": "",
  "endDate": "",
  "currencies": [
    "USD",
    "EUR",
    "GBP",
    "JPY"
  ],
  "impactLevels": [
    "high",
    "medium"
  ],
  "includeDetail": false,
  "maxEvents": 1000,
  "concurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "currencies": [
        "USD",
        "EUR",
        "GBP",
        "JPY"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/forexfactory-economic-calendar").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 = {
    "currencies": [
        "USD",
        "EUR",
        "GBP",
        "JPY",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/forexfactory-economic-calendar").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 '{
  "currencies": [
    "USD",
    "EUR",
    "GBP",
    "JPY"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapemint/forexfactory-economic-calendar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ForexFactory Economic Calendar Scraper (No Login)",
        "description": "Pull the public ForexFactory economic calendar by date range. Returns event date, time, currency, impact rating (high/med/low), title, actual, forecast, previous, revised values, and source. JSON. No login. Pay per event.",
        "version": "0.1",
        "x-build-id": "7SaWx0hAWamXkMck2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~forexfactory-economic-calendar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-forexfactory-economic-calendar",
                "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/scrapemint~forexfactory-economic-calendar/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-forexfactory-economic-calendar",
                "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/scrapemint~forexfactory-economic-calendar/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-forexfactory-economic-calendar",
                "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": {
                    "range": {
                        "title": "Date range",
                        "enum": [
                            "today",
                            "tomorrow",
                            "yesterday",
                            "this_week",
                            "next_week",
                            "last_week",
                            "this_month",
                            "next_month",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Preset date window. Choose 'custom' to use startDate and endDate.",
                        "default": "this_week"
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "First date to pull, inclusive. Required when range is 'custom'. Format YYYY-MM-DD.",
                        "default": ""
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Last date to pull, inclusive. Required when range is 'custom'. Max 30 days span. Format YYYY-MM-DD.",
                        "default": ""
                    },
                    "currencies": {
                        "title": "Currencies",
                        "type": "array",
                        "description": "ISO currency codes to include. Empty pulls every currency on the calendar.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "impactLevels": {
                        "title": "Impact levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Impact ratings to include. Default keeps high and medium only. Add 'low' or 'holiday' to widen.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "high",
                                "medium",
                                "low",
                                "holiday"
                            ],
                            "enumTitles": [
                                "High",
                                "Medium",
                                "Low",
                                "Holiday or non-economic"
                            ]
                        },
                        "default": [
                            "high",
                            "medium"
                        ]
                    },
                    "includeDetail": {
                        "title": "Include event detail",
                        "type": "boolean",
                        "description": "Fetch each event's detail page for description, source agency, frequency, and revision history. Adds one extra request per event.",
                        "default": false
                    },
                    "maxEvents": {
                        "title": "Max events",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many event rows. Default 1000 covers a full month of high+medium events.",
                        "default": 1000
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of pages processed in parallel. Three is a safe default for ForexFactory.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential is required at any meaningful volume.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
