# tradingview-webhook-json-validator (`algoway/tradingview-webhook-json-validator`) Actor

AlgoWay TradingView Webhook JSON Validator

- **URL**: https://apify.com/algoway/tradingview-webhook-json-validator.md
- **Developed by:** [AlgoWay](https://apify.com/algoway) (community)
- **Categories:** AI, Automation, Developer tools
- **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

## AlgoWay TradingView Webhook JSON Validator

This Apify Actor validates TradingView webhook JSON payloads for AlgoWay-style trade automation.

It is a public technical Actor for traders, developers, automation builders and API users who work with:

- TradingView webhook alerts
- Telegram trading signals
- AI-parsed trading signals
- MT5 automation
- broker API routing
- crypto exchange execution
- multi-platform trade execution

AlgoWay website: https://algoway.trade  
AlgoWay docs: https://docs.algoway.trade  
TradersPost alternative page: https://algoway.trade/traderspost-alternative  

### What this Actor does

This Actor accepts a webhook-style trading payload and checks the basic structure before the payload is sent to a trading execution layer.

It validates:

- `symbol`
- `order_action`
- `order_type`
- `price` for limit and stop orders
- `volume`
- `trade_type`
- `sl_price`
- `tp_price`

The Actor writes the validation result to the default dataset and to the key-value store under `OUTPUT`.

### Example input

```json
{
  "symbol": "EURUSD",
  "order_action": "buy",
  "order_type": "market",
  "volume": 0.1,
  "trade_type": "hedge",
  "sl_price": 1.08,
  "tp_price": 1.095,
  "comment": "TradingView alert via AlgoWay"
}
````

### Example input with payload wrapper

```json
{
  "payload": {
    "symbol": "XAUUSD",
    "order_action": "buy",
    "order_type": "limit",
    "price": 2320.5,
    "volume": 0.1,
    "trade_type": "netting",
    "sl_price": 2308,
    "tp_price": 2345,
    "comment": "Limit order from webhook payload"
  }
}
```

### Example input as JSON string

```json
{
  "payload": "{\"symbol\":\"EURUSD\",\"order_action\":\"buy\",\"order_type\":\"market\",\"volume\":0.1,\"trade_type\":\"hedge\"}"
}
```

### Supported order actions

```text
buy
sell
close
flat
closeall
```

### Supported order types

```text
market
limit
stop
```

For `limit` and `stop` orders, the payload should include `price` as the entry price.

### Supported trade types

```text
hedge
netting
opposite
inverse
```

In AlgoWay logic, `netting` can be mapped internally to reverse-style handling.

The `inverse` mode reverses buy and sell logic for the specific payload.

### Example output

```json
{
  "title": "AlgoWay TradingView Webhook JSON Validator",
  "description": "Public Apify Actor for validating TradingView webhook JSON payloads for AlgoWay, MT5 automation, Telegram signals and multi-platform trade execution.",
  "payload": {
    "symbol": "EURUSD",
    "order_action": "buy",
    "order_type": "market",
    "volume": 0.1,
    "trade_type": "hedge",
    "sl_price": 1.08,
    "tp_price": 1.095,
    "comment": "TradingView alert via AlgoWay"
  },
  "validation": {
    "valid": true,
    "errors": [],
    "warnings": [],
    "messages": [
      "symbol accepted: EURUSD",
      "order_action accepted: buy",
      "order_type accepted: market",
      "trade_type accepted: hedge"
    ]
  },
  "links": {
    "website": "https://algoway.trade",
    "docs": "https://docs.algoway.trade",
    "tradersPostAlternative": "https://algoway.trade/traderspost-alternative"
  }
}
```

### Supported signal sources

AlgoWay is designed to work with multiple signal inputs:

- TradingView webhook alerts
- Telegram trading signals
- AI Telegram signal copier workflows
- TrendSpider webhooks and Strategy Bots
- MT5 Copier source
- cTrader Copier source
- Manual webhook JSON
- Custom JSON and API-style webhook payloads

### Supported execution destinations

AlgoWay can route validated trade instructions to multiple execution destinations:

- MetaTrader 5 / MT5
- TradeLocker
- Match-Trader
- DXtrade
- cTrader
- cTrader Open API
- FIX API / FIX-based execution
- Forex.com
- OANDA
- Capital.com
- Alpaca
- Tradovate
- ProjectX
- Binance
- Bybit
- OKX
- BingX
- MEXC
- BitMEX
- BitMart
- Bitget
- Coinbase
- Gate.io

### AlgoWay as a TradersPost alternative

AlgoWay can be used as a TradersPost alternative when the goal is to route TradingView webhook alerts beyond a single broker connection.

Instead of only receiving a webhook alert, AlgoWay focuses on:

- webhook validation
- JSON payload control
- trade routing
- execution logs
- Telegram signal automation
- MT5 automation
- crypto exchange routing
- multi-platform trade execution

AlgoWay website: https://algoway.trade\
AlgoWay docs: https://docs.algoway.trade\
TradersPost alternative: https://algoway.trade/traderspost-alternative

### Notes

This Actor is a public validation demo.

Real trade execution requires account settings, broker rules, symbol mapping, risk settings, destination-specific validation and an active execution route.

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("algoway/tradingview-webhook-json-validator").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("algoway/tradingview-webhook-json-validator").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 '{}' |
apify call algoway/tradingview-webhook-json-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=algoway/tradingview-webhook-json-validator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "tradingview-webhook-json-validator",
        "description": "AlgoWay TradingView Webhook JSON Validator",
        "version": "0.0",
        "x-build-id": "0w3TWu3ShPZLMCSng"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/algoway~tradingview-webhook-json-validator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-algoway-tradingview-webhook-json-validator",
                "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/algoway~tradingview-webhook-json-validator/runs": {
            "post": {
                "operationId": "runs-sync-algoway-tradingview-webhook-json-validator",
                "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/algoway~tradingview-webhook-json-validator/run-sync": {
            "post": {
                "operationId": "run-sync-algoway-tradingview-webhook-json-validator",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
