# TradingView Economic Calendar Scraper (`automation-lab/tradingview-economic-calendar-scraper`) Actor

Extract TradingView macroeconomic calendar events by date range and country. Get importance, actual, forecast, previous values, units, tickers, explanations, and primary source links for alerts and research.

- **URL**: https://apify.com/automation-lab/tradingview-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

## TradingView Economic Calendar Scraper

Extract **TradingView economic calendar** events by date range and country without a login or API key.
Get scheduled macro releases, importance, actual, forecast, previous values, units, indicators, tickers, explanations, and primary source links as structured JSON, CSV, Excel, or XML.

Use a seven-day default run for a quick week-ahead calendar, or schedule the Actor to refresh your catalyst feed every day.
The scraper uses TradingView's public JSON surface directly, so it avoids browser overhead while preserving rich TradingView-specific metadata.

### What does TradingView Economic Calendar Scraper do?

TradingView Economic Calendar Scraper turns the public [TradingView economic calendar](https://www.tradingview.com/economic-calendar/) into automation-ready event records.

It can:

- 📅 Fetch an inclusive UTC date range up to 366 days.
- 🌍 Filter by one or more two-letter country codes.
- 🚦 Filter Low, Medium, or High importance events.
- 🗂️ Filter TradingView category codes such as `hse`, `prce`, or `enrg`.
- 📈 Preserve actual, forecast, previous, and raw numeric values.
- 🔗 Return primary publisher links and TradingView economics tickers.
- 🧹 Remove duplicate event IDs and sort results chronologically.
- 🔄 Split long ranges into bounded requests automatically.

No TradingView account, cookies, or private API token is required.

### Who is this economic calendar scraper for?

**Traders and portfolio managers**

- Build a daily catalyst list before the market opens.
- Alert on high-importance releases for currencies and regions you trade.
- Compare released actual values with consensus forecasts.

**Quantitative researchers**

- Join macro release timestamps to price and volatility data.
- Store stable TradingView event IDs for later updates.
- Backfill a bounded historical range for event studies.

**Market-news and fintech teams**

- Populate an economic-events widget or editorial planning queue.
- Enrich alerts with indicator explanations and primary sources.
- Feed normalized calendar records into APIs, dashboards, and databases.

**Automation builders**

- Schedule week-ahead exports to Google Sheets.
- Trigger Slack, Discord, email, Make, or Zapier workflows.
- Monitor actual-versus-forecast changes after release time.

### Why use this TradingView calendar extractor?

- **Rich source fields:** get indicator, period, reference date, category, explanation, ticker, and raw values.
- **HTTP-first performance:** no Chromium startup or page rendering.
- **No login:** the useful calendar surface is public.
- **Precise filtering:** country and importance filters are enforced locally as well as upstream.
- **Stable records:** event IDs support deduplication and downstream upserts.
- **Long ranges:** requests are split into safe 7-day windows.
- **Apify platform:** use schedules, webhooks, API access, datasets, monitoring, and integrations.
- **Export anywhere:** download JSON, CSV, Excel, XML, or RSS-compatible transformed data.

### What TradingView economic calendar data can you extract?

| Group | Fields | Description |
|---|---|---|
| Identity | `eventId`, `title`, `indicator` | Stable ID and event names |
| Market | `country`, `currency`, `importance`, `importanceLabel` | Geography, currency, and impact |
| Timing | `scheduledAt`, `period`, `referenceDate` | Release and reporting dates |
| Values | `actual`, `forecast`, `previous` | Display values from TradingView |
| Raw values | `actualRaw`, `forecastRaw`, `previousRaw`, `unit` | Analysis-ready source values |
| Metadata | `category`, `explanation`, `tradingViewTicker` | TradingView-specific context |
| Sources | `source`, `sourceUrl`, `tradingViewUrl` | Publisher and calendar links |
| Provenance | `scrapedAt` | UTC extraction timestamp |

Forecasts or actual values may be `null` before a release or when the source does not provide them.
The Actor preserves those nulls rather than guessing.

### How much does it cost to scrape TradingView economic calendar events?

This Actor uses **pay-per-event** pricing.
A run has a $0.005 start charge, then a tiered charge for each saved calendar event.

| Apify plan | Price per event | 1,000 events plus start |
|---|---:|---:|
| Free | $0.000035799 | $0.040799 |
| Starter / Bronze | $0.00003113 | $0.03613 |
| Scale / Silver | $0.000024281 | $0.029281 |
| Business / Gold | $0.000018678 | $0.023678 |
| Platinum | $0.000012452 | $0.017452 |
| Diamond | $0.00001 | $0.015 |

You pay only for records saved to your dataset.
Filtering at the source and in the Actor helps avoid paying for irrelevant events.
Start with `maxItems: 20` to validate a workflow cheaply.

### How to scrape TradingView economic calendar data

1. Open TradingView Economic Calendar Scraper on Apify.
2. Leave dates empty for today through the next seven days, or enter `dateFrom` and `dateTo`.
3. Add country codes such as `US`, `GB`, `DE`, `JP`, or `CA` if needed.
4. Select importance levels for a focused catalyst calendar.
5. Set a maximum number of events.
6. Click **Start**.
7. Open the Dataset tab to preview or export results.
8. Add a schedule or webhook for repeat monitoring.

**Week-ahead US calendar**

```json
{
  "daysAhead": 7,
  "countries": ["US"],
  "maxItems": 100
}
````

**High-importance G7 releases**

```json
{
  "daysAhead": 30,
  "countries": ["US", "GB", "DE", "FR", "IT", "CA", "JP"],
  "importance": ["High"],
  "maxItems": 1000
}
```

**Explicit research range**

```json
{
  "dateFrom": "2026-07-01",
  "dateTo": "2026-07-31",
  "importance": ["High", "Medium"],
  "maxItems": 2000
}
```

### Input parameters

| Parameter | Type | Default | What it controls |
|---|---|---|---|
| `dateFrom` | string | today | Inclusive UTC start date (`YYYY-MM-DD`) |
| `dateTo` | string | derived | Inclusive UTC end date (`YYYY-MM-DD`) |
| `daysAhead` | integer | `7` | Horizon when `dateTo` is empty |
| `countries` | string\[] | `[]` | ISO two-letter country filters |
| `importance` | string\[] | `[]` | Low, Medium, and/or High filters |
| `categories` | string\[] | `[]` | TradingView category-code filters |
| `maxItems` | integer | `500` | Maximum matching records saved |
| `proxyConfiguration` | object | disabled | Optional final-retry proxy fallback |

An empty filter array means all values.
The maximum inclusive date span is 366 days.
The maximum `maxItems` value is 10,000.

### Output example

```json
{
  "eventId": "398066",
  "title": "Building Permits MoM Prel",
  "indicator": "Building Permits MoM",
  "country": "US",
  "currency": "USD",
  "category": "hse",
  "period": "Jun",
  "referenceDate": "2026-06-30T00:00:00Z",
  "scheduledAt": "2026-07-17T12:30:00.000Z",
  "importance": 0,
  "importanceLabel": "Medium",
  "actual": -3,
  "forecast": null,
  "previous": -0.9,
  "actualRaw": -3,
  "forecastRaw": null,
  "previousRaw": -0.9,
  "unit": "%",
  "explanation": "Building Permits refer to approvals given before construction...",
  "tradingViewTicker": "ECONOMICS:USBPMM",
  "source": "Census Bureau",
  "sourceUrl": "https://www.census.gov/",
  "tradingViewUrl": "https://www.tradingview.com/economic-calendar/",
  "scrapedAt": "2026-07-17T13:00:00.000Z"
}
```

Numbers remain numbers when TradingView sends numeric values.
Missing source values remain `null`.

### Filter by country, importance, or category

Country values use ISO alpha-2 codes rather than currency codes.
For example, use `US` for United States releases and `GB` for United Kingdom releases.

Importance maps TradingView's source values to readable labels:

| Source value | Label |
|---:|---|
| `-1` | Low |
| `0` | Medium |
| `1` | High |

Category codes are TradingView's compact classifications.
Common observed examples include:

- `hse` — housing indicators.
- `prce` — price and inflation indicators.
- `bsnss` — business indicators.
- `cnsm` — consumer indicators.
- `enrg` — energy indicators.

Leave `categories` empty if you do not want to depend on source-specific codes.

### Tips for reliable economic-event feeds

- Start with seven days and a low `maxItems` value.
- Use country filters to keep alert feeds relevant.
- Store `eventId` as your downstream upsert key.
- Schedule one run before market open and another after major releases.
- Preserve both display and raw values for auditability.
- Treat `forecast: null` as “not supplied,” not zero.
- Use UTC timestamps in downstream systems before converting to local time.
- Keep proxy disabled unless direct requests fail in your environment.
- Use a webhook to process results immediately after a scheduled run.

### Schedule daily and weekly calendar monitors

A daily schedule can fetch the next seven days and update your calendar table.
A weekly schedule can collect a broader 30-day planning horizon.

Recommended patterns:

- **Morning risk brief:** run at 05:00 UTC with High and Medium importance.
- **Release monitor:** run every 30–60 minutes on important release days.
- **Research archive:** run once daily and upsert by `eventId`.
- **Editorial calendar:** fetch 30 days across target countries every Monday.

Events may receive actual values after their scheduled release.
Repeated runs let your downstream database update the same event ID.

### Integrate TradingView calendar data

**TradingView calendar → Google Sheets**

Schedule a daily run and use the Google Sheets integration to maintain a shared catalyst calendar for a trading desk.

**TradingView calendar → Slack or Discord**

Send High-importance events to a channel before release time, then post actual-versus-forecast values afterward.

**TradingView calendar → Make or Zapier**

Create calendar entries, CRM tasks, editorial tickets, or notification workflows from newly observed event IDs.

**TradingView calendar → database or warehouse**

Use a webhook to upsert events into PostgreSQL, BigQuery, Snowflake, or a time-series research store.

**TradingView calendar → AI research agent**

Give an agent the next week's events and ask it to prepare indicator background notes using the explanation and source URL.

### Use the Apify API with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tradingview-economic-calendar-scraper').call({
  daysAhead: 7,
  countries: ['US', 'GB'],
  importance: ['High'],
  maxItems: 200,
});

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

### Use the Apify API with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/tradingview-economic-calendar-scraper").call(
    run_input={
        "daysAhead": 7,
        "countries": ["US"],
        "importance": ["High", "Medium"],
        "maxItems": 200,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tradingview-economic-calendar-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"daysAhead":7,"countries":["US"],"importance":["High"],"maxItems":100}'
```

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

### Use with AI agents via MCP

TradingView Economic Calendar Scraper is available to assistants that support the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

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

For Claude Desktop, Cursor, or VS Code:

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

Example prompts:

- “Use `automation-lab/tradingview-economic-calendar-scraper` to list next week's High-importance US releases.”
- “Build a G7 macro catalyst table with release time, forecast, previous value, indicator, and source.”
- “Refresh today's events and identify releases where actual differs from forecast.”

Authentication uses your Apify account through the hosted MCP server.

### Is it legal to scrape TradingView economic calendar data?

This Actor accesses publicly available calendar data without bypassing login controls.
Web scraping legality depends on jurisdiction, purpose, contractual obligations, and how data is stored or redistributed.

Use the Actor responsibly:

- Follow applicable laws and TradingView's terms.
- Collect only data needed for a legitimate purpose.
- Respect intellectual-property and database rights.
- Avoid presenting source data as investment advice.
- Review primary publisher terms before redistributing their content.
- Apply appropriate retention, attribution, and access controls.

This documentation is not legal advice.

### FAQ

**How fast is the TradingView economic calendar scraper?**

It uses direct HTTP JSON requests rather than a browser. A typical one-week request usually needs one source request plus dataset writing time.

**Why are actual or forecast values null?**

TradingView may not publish an actual value before release time, and some events have no consensus forecast. Null means the source did not provide a value.

**Why did my filters return no events?**

Check that country values are two-letter codes such as `US`, not currency codes such as `USD`. Also broaden the date range or importance filter.

**Can I request historical dates?**

Yes. Set explicit `dateFrom` and `dateTo` values with a maximum span of 366 days per run.

**Does this use TradingView's official paid API?**

No. It reads the public economic-calendar JSON surface and does not require a private API key or account.

**How are duplicate events handled?**

The Actor deduplicates records by TradingView's event ID across every bounded date window.

**Can I monitor post-release updates?**

Yes. Schedule repeat runs and upsert results by `eventId` so actual values can replace earlier nulls.

**Is a proxy required?**

No. Direct anonymous HTTP is the default. Optional Apify Proxy settings are used only on the final retry when configured.

### Related finance and TradingView scrapers

Explore related tools from Automation Lab:

- [TradingView Scraper](https://apify.com/automation-lab/tradingview-scraper) — stock screener data.
- [TradingView Community Ideas Strategy Scraper](https://apify.com/automation-lab/tradingview-community-ideas-strategy-scraper) — community trading ideas.
- [Forex Factory Economic Calendar Scraper](https://apify.com/automation-lab/forex-factory-economic-calendar-scraper) — an alternative calendar source.
- [Yahoo Finance Scraper](https://apify.com/automation-lab/yahoo-finance-scraper) — market quotes and finance data.
- [Finviz Scraper](https://apify.com/automation-lab/finviz-scraper) — stock screening and market data.

Choose TradingView Economic Calendar Scraper when you need TradingView's richer macro indicator metadata and source fields.

### Support and responsible use

If a run fails, include the run ID, input date range, and country filters in an Apify issue.
Do not include account credentials or private tokens.

For stable production workflows:

- Pin your downstream schema to documented fields.
- Monitor failed runs through Apify notifications.
- Keep a raw dataset archive for audit and replay.
- Validate source attribution requirements for your use case.
- Test a small range before increasing limits.

The Actor is designed for repeatable research and automation, not individualized financial advice.

# Actor input Schema

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

Include events on or after this UTC date in YYYY-MM-DD format.

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

Include events through this UTC date in YYYY-MM-DD format. The maximum range is 366 days.

## `daysAhead` (type: `integer`):

When End date is empty, fetch this many days after Start date (or today).

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

Only save events for these ISO two-letter country codes, such as US, GB, DE, JP, or CA.

## `importance` (type: `array`):

Only save TradingView events with the selected market importance.

## `categories` (type: `array`):

Optional TradingView category codes such as hse, prce, bsnss, cnsm, or enrg. Leave empty for all categories.

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

Stop after this many matching events, sorted by scheduled time.

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

Optional Apify Proxy settings used only on the final retry after direct requests fail.

## Actor input object example

```json
{
  "daysAhead": 7,
  "countries": [
    "US"
  ],
  "importance": [],
  "categories": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "daysAhead": 7,
    "countries": [
        "US"
    ],
    "importance": [],
    "categories": [],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tradingview-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 = {
    "daysAhead": 7,
    "countries": ["US"],
    "importance": [],
    "categories": [],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tradingview-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 '{
  "daysAhead": 7,
  "countries": [
    "US"
  ],
  "importance": [],
  "categories": [],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/tradingview-economic-calendar-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView Economic Calendar Scraper",
        "description": "Extract TradingView macroeconomic calendar events by date range and country. Get importance, actual, forecast, previous values, units, tickers, explanations, and primary source links for alerts and research.",
        "version": "0.1",
        "x-build-id": "wa1eEeeZxaXKNkuzi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tradingview-economic-calendar-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tradingview-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~tradingview-economic-calendar-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tradingview-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~tradingview-economic-calendar-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tradingview-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": {
                    "dateFrom": {
                        "title": "Start date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Include events on or after this UTC date in YYYY-MM-DD format."
                    },
                    "dateTo": {
                        "title": "End date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Include events through this UTC date in YYYY-MM-DD format. The maximum range is 366 days."
                    },
                    "daysAhead": {
                        "title": "Days ahead",
                        "minimum": 0,
                        "maximum": 366,
                        "type": "integer",
                        "description": "When End date is empty, fetch this many days after Start date (or today).",
                        "default": 7
                    },
                    "countries": {
                        "title": "Country codes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only save events for these ISO two-letter country codes, such as US, GB, DE, JP, or CA.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2}$"
                        },
                        "default": []
                    },
                    "importance": {
                        "title": "Importance levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only save TradingView events with the selected market importance.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "High",
                                "Medium",
                                "Low"
                            ],
                            "enumTitles": [
                                "High importance",
                                "Medium importance",
                                "Low importance"
                            ]
                        },
                        "default": []
                    },
                    "categories": {
                        "title": "Category codes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional TradingView category codes such as hse, prce, bsnss, cnsm, or enrg. Leave empty for all categories.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z0-9_-]{1,30}$"
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many matching events, sorted by scheduled time.",
                        "default": 500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings used only on the final retry after direct requests fail.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```