# ForexFactory Economic Calendar Scraper | Fast, No API Key (`bovi/forex-economic-calendar-scraper`) Actor

Scrape ForexFactory's economic calendar: date/time, currency, impact, actual/forecast/previous/revised values, plus source, frequency and description per indicator (detail mode). Today, this/next/last week or month. No API key, no login.

- **URL**: https://apify.com/bovi/forex-economic-calendar-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.64 / 1,000 event\_rows

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

## ForexFactory Economic Calendar Scraper

For forex/futures traders, quant research pipelines, and AI trading agents that need structured economic-release
data — no API key, no login, no headless browser.

**No API key required.** No ForexFactory account. **Pay Per Event** — you're charged one `event_row` per calendar
event returned. Every record includes `parseConfidence` (0.0–1.0) and `warnings`.

Scrape ForexFactory's public economic calendar (`forexfactory.com/calendar`) — one of the most widely used free
forex-trader calendars on the web. Date/time (UTC), currency, impact level, actual/forecast/previous/revised
values with parsed numeric variants, and — with **detail mode** switched on — the data source, release
frequency, and a plain-English description of what each indicator measures.

---

### Why this actor over the alternatives

Most ForexFactory scrapers on the Store only read the base calendar page. That page genuinely does **not** carry
a data source, release frequency, or indicator description — those live on a separate per-indicator detail page.
The common result: `source` / `frequency` / `description` fields declared in the output schema but sitting at
0% fill-rate forever, on every rival that only reads the base page.

This actor closes that gap. With `includeDetail: true`, it fetches each **distinct indicator's** ForexFactory
detail page once per run (deduped by indicator — one extra request per unique indicator in your result set, not
per event row) and folds `source`, `sourceUrl`, `frequency`, `eventDescription`, `usualEffect`, `alsoCalled`, and
`eventType` into every matching event.

| Field | Base calendar page | This actor (`includeDetail: true`) |
|---|---|---|
| date / time / currency / impact | ✅ | ✅ |
| actual / forecast / previous / revised (+ numeric) | ✅ | ✅ |
| `source`, `sourceUrl` | ❌ not on this page | ✅ |
| `frequency` | ❌ not on this page | ✅ |
| `eventDescription` (what the indicator measures) | ❌ not on this page | ✅ |
| `usualEffect`, `alsoCalled`, `eventType` | ❌ not on this page | ✅ (bonus — not on the base page at all) |

---

### What data you get

One record per calendar event:

- `eventId` — stable composite key, `<date>-<currency>-<slug(eventTitle)>` (e.g. `2026-07-21-GBP-claimant-count-change`)
- `url`, `soloUrl` — deep link into the calendar and the indicator's own detail page
- `date`, `time`, `timestamp` — UTC (derived from ForexFactory's own event epoch, not a display-timezone guess), `displayTimezone`
- `country`, `currency`, `impact` (low/medium/high/holiday), `eventTitle`, `isAllDay`, `leaked`
- `actual`, `actualNumeric`, `forecast`, `forecastNumeric`, `previous`, `previousNumeric`, `revised`, `revisedNumeric`, `unit`
- Detail mode only: `source`, `sourceUrl`, `frequency`, `eventDescription`, `usualEffect`, `alsoCalled`, `eventType`, `detailFetched`
- `scrapedAt`, `parseConfidence`, `warnings`

`actual`/`revised` are legitimately empty for events that haven't happened yet (a forward-looking `this_week` /
`next_week` window) — that's the real state of the data, not a parser gap.

---

### How to use

#### This week's high/medium impact USD/EUR/GBP/JPY events

```json
{
  "range": "this_week",
  "currencies": ["USD", "EUR", "GBP", "JPY"],
  "impactLevels": ["high", "medium"],
  "includeDetail": false,
  "maxEvents": 50
}
````

#### Today's events with full indicator detail (source/frequency/description)

```json
{
  "range": "today",
  "includeDetail": true,
  "maxEvents": 30
}
```

#### All currencies, next month, high impact only

```json
{
  "range": "next_month",
  "impactLevels": ["high"],
  "maxEvents": 300
}
```

***

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `range` | enum | `this_week` | `today` / `tomorrow` / `yesterday` / `this_week` / `next_week` / `last_week` / `this_month` / `next_month` / `last_month` |
| `currencies` | array of string | `[]` (all) | Currency codes to keep, e.g. `USD`, `EUR`, `GBP`, `JPY` |
| `impactLevels` | array of string | `[]` (all) | Subset of `low` / `medium` / `high` / `holiday` |
| `includeDetail` | boolean | `false` | Fetch each distinct indicator's detail page once to fill source/frequency/description |
| `maxEvents` | integer | `200` | Cap on rows returned (after filtering), hard max `1000` |
| `proxyConfiguration` | object | RESIDENTIAL | Apify Proxy settings — works out of the box, no proxy key needed from you |

***

### Pricing

Pay Per Event: **`event_row`** — one charge per calendar-event record returned. `includeDetail: true` adds no
extra per-row charge; the indicator detail fetch is internal COGS, deduped by indicator across your whole run.

***

### Legal

ForexFactory's `/calendar` is a public, unauthenticated page — no login wall, no paywall. This actor reads only
that publicly available economic-release schedule; it does not access any account-gated ForexFactory content
(forums, trade-journal, member tools). Data is provided for informational purposes; it is not investment advice.

***

### MCP / AI agent integration

This actor works as an Apify MCP tool — call it from Claude, GPT, or any MCP-compatible agent to pull a
structured economic calendar into a trading research pipeline without scraping code of your own.

# Actor input Schema

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

Which calendar window to scrape. ForexFactory resolves the keyword server-side, so results are always the site's current window for that keyword.

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

Currency codes to keep, e.g. USD, EUR, GBP, JPY. Leave empty to keep all currencies.

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

Which impact levels to keep: low, medium, high, holiday. Leave empty to keep all.

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

Fetch each distinct indicator's ForexFactory detail page once (deduped — one extra request per distinct indicator in the result set, not per event row) to fill source, frequency, description, plus bonus fields (sourceUrl, usualEffect, alsoCalled, eventType). Off by default to keep runs fast/cheap.

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

Cap on the number of event rows returned, applied after currency/impact filtering. Default 200, hard cap 1000.

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

Apify Proxy settings. Defaults to RESIDENTIAL — the actor works out of the box, no proxy key from you required.

## Actor input object example

```json
{
  "range": "this_week",
  "currencies": [
    "USD",
    "EUR",
    "GBP",
    "JPY"
  ],
  "impactLevels": [
    "high",
    "medium"
  ],
  "maxEvents": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing calendar event records (eventId, date, time, currency, impact, eventTitle, forecast/actual/previous/revised + numeric variants, unit, and — when includeDetail is on — source/frequency/eventDescription).

# 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 = {
    "range": "this_week",
    "currencies": [
        "USD",
        "EUR",
        "GBP",
        "JPY"
    ],
    "impactLevels": [
        "high",
        "medium"
    ],
    "includeDetail": false,
    "maxEvents": 200,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/forex-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 = {
    "range": "this_week",
    "currencies": [
        "USD",
        "EUR",
        "GBP",
        "JPY",
    ],
    "impactLevels": [
        "high",
        "medium",
    ],
    "includeDetail": False,
    "maxEvents": 200,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/forex-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 '{
  "range": "this_week",
  "currencies": [
    "USD",
    "EUR",
    "GBP",
    "JPY"
  ],
  "impactLevels": [
    "high",
    "medium"
  ],
  "includeDetail": false,
  "maxEvents": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/forex-economic-calendar-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ForexFactory Economic Calendar Scraper | Fast, No API Key",
        "description": "Scrape ForexFactory's economic calendar: date/time, currency, impact, actual/forecast/previous/revised values, plus source, frequency and description per indicator (detail mode). Today, this/next/last week or month. No API key, no login.",
        "version": "0.1",
        "x-build-id": "TEabRU7K2lTfl3Grr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~forex-economic-calendar-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-forex-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/bovi~forex-economic-calendar-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-forex-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/bovi~forex-economic-calendar-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-forex-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": {
                    "range": {
                        "title": "Date range",
                        "enum": [
                            "today",
                            "tomorrow",
                            "yesterday",
                            "this_week",
                            "next_week",
                            "last_week",
                            "this_month",
                            "next_month",
                            "last_month"
                        ],
                        "type": "string",
                        "description": "Which calendar window to scrape. ForexFactory resolves the keyword server-side, so results are always the site's current window for that keyword."
                    },
                    "currencies": {
                        "title": "Currencies",
                        "type": "array",
                        "description": "Currency codes to keep, e.g. USD, EUR, GBP, JPY. Leave empty to keep all currencies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "impactLevels": {
                        "title": "Impact levels",
                        "type": "array",
                        "description": "Which impact levels to keep: low, medium, high, holiday. Leave empty to keep all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "low",
                                "medium",
                                "high",
                                "holiday"
                            ],
                            "enumTitles": [
                                "Low",
                                "Medium",
                                "High",
                                "Holiday"
                            ]
                        }
                    },
                    "includeDetail": {
                        "title": "Include indicator detail (source / frequency / description)",
                        "type": "boolean",
                        "description": "Fetch each distinct indicator's ForexFactory detail page once (deduped — one extra request per distinct indicator in the result set, not per event row) to fill source, frequency, description, plus bonus fields (sourceUrl, usualEffect, alsoCalled, eventType). Off by default to keep runs fast/cheap."
                    },
                    "maxEvents": {
                        "title": "Max events",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on the number of event rows returned, applied after currency/impact filtering. Default 200, hard cap 1000."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Defaults to RESIDENTIAL — the actor works out of the box, no proxy key from you required.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
