# TradingView Ideas & Strategy Scraper (`automation-lab/tradingview-community-ideas-strategy-scraper`) Actor

📈 Turn public TradingView Ideas into a research-ready dataset of strategy notes, symbols, authors, engagement, and chart links.

- **URL**: https://apify.com/automation-lab/tradingview-community-ideas-strategy-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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.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

## TradingView Ideas & Strategy Scraper

Collect publicly visible TradingView community Ideas into a structured dataset.

No TradingView login, personal feed, or trading account is required.

Use it to turn public charts, strategy notes, author activity, and engagement into research-ready rows.

### What does it do?

This scraper visits public TradingView Ideas feeds, symbol pages, category pages, and author pages.

It saves one record for each visible community Idea.

Records include a title, chart link, symbol, author, publishing time, visible strategy direction, excerpt, comments, boosts, and chart image URL.

Optional enrichment visits the public Idea page for additional metadata when available.

### Who is it for?

Investment-research analysts can monitor a public symbol feed without manually copying cards.

Quant-research teams can build a repeatable public-signal dataset for offline analysis.

Trading-content teams can track author activity, themes, and community engagement.

Market-intelligence teams can preserve public editorial ideas with collection provenance.

### Why use it?

TradingView cards are useful for browsing but difficult to filter, compare, or export at scale.

This actor converts the visible public information into JSON, CSV, Excel, or an API dataset.

Each record retains its source URL so a researcher can inspect the original public page.

### Public-only scope

The actor only requests public TradingView pages.

It does not sign in, use cookies from your account, access watchlists, create alerts, or place trades.

Do not submit private or authenticated URLs.

### Data you receive

| Field | Description |
|---|---|
| `ideaUrl` | Public chart/Idea URL |
| `title` | Visible Idea title |
| `symbol` | Visible market symbol when shown |
| `author` | Public author name |
| `publishedAt` | Card publication timestamp |
| `direction` | Visible Long or Short signal when shown |
| `descriptionExcerpt` | Public card/detail description |
| `comments` | Visible comment count |
| `likes` | Visible boost count |
| `chartImageUrl` | Public preview image URL |

### Quick start

1. Add `https://www.tradingview.com/ideas/` as a public source URL.

2. Set `maxItems` to 10 for a first run.

3. Run the actor.

4. Export the dataset or connect it to your analysis workflow.

### Input: public source URLs

Use a public Ideas page as the most predictable collection source.

Examples include the Ideas landing page, a public symbol Ideas page, a public category page, or a public author page.

The actor validates that URLs belong to `tradingview.com` and are public Idea-related paths.

### Input: keyword

A keyword produces a best-effort public Ideas query.

For recurring production workflows, prefer a stable source URL because public site search can change.

Leave the keyword blank when using source URLs.

### Input: maximum Ideas

`maxItems` limits saved records from 1 through 500.

Start with 10 to confirm that a chosen source returns the public cards you expect.

Increase it only after checking the output quality.

### Input: detail enrichment

Enable `enrichDetails` to visit public Idea pages after parsing feed cards.

This can add public description, image, and timing metadata.

It is slower than feed-only collection.

If a detail page is unavailable, the actor keeps the already-collected feed record.

### Output example

```json
{
  "title": "XAU SHORT$",
  "symbol": "OANDA:XAUUSD",
  "author": "JupahduhX",
  "direction": "Short",
  "comments": 69,
  "ideaUrl": "https://www.tradingview.com/chart/XAUUSD/.../"
}
````

### Interpreting engagement

`comments` is the visible public comment count.

`likes` records the public card’s visible boost count where TradingView exposes it.

`views` and `tags` are optional because they are not present on every public layout.

Null means the field was not publicly displayed, not that the actor guessed a value.

### Soft block behavior

Public sites can filter, redesign, or temporarily rate-limit individual pages.

The actor logs a warning and skips an unavailable feed rather than discarding records saved from other feeds.

A successful run can therefore contain partial results when one source is unavailable.

### Tips for research quality

Use one symbol or author source per recurring job for clean provenance.

Keep feed-only runs for broad monitoring.

Use detail enrichment for smaller, higher-value investigations.

Store `collectedAt` alongside `publishedAt` when measuring recency.

### Integrations

Send the dataset to Google Sheets for an analyst review queue.

Use a webhook to trigger a research-notebook import after each run.

Join `symbol`, `author`, and `publishedAt` with your internal signal or content database.

Use the Apify API to load rows into Python, R, or a warehouse.

### API usage: Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tradingview-community-ideas-strategy-scraper').call({
  startUrls: [{ url: 'https://www.tradingview.com/ideas/' }], maxItems: 10
});
console.log(await client.dataset(run.defaultDatasetId).listItems());
```

### API usage: Python

```python
from apify_client import ApifyClient
client = ApifyClient()
run = client.actor('automation-lab/tradingview-community-ideas-strategy-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.tradingview.com/ideas/'}], 'maxItems': 10
})
print(list(client.dataset(run['defaultDatasetId']).iterate_items()))
```

### API usage: cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~tradingview-community-ideas-strategy-scraper/runs?token=$APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"startUrls":[{"url":"https://www.tradingview.com/ideas/"}],"maxItems":10}'
```

### MCP for AI assistants

Use this actor through Apify MCP in Claude Code or Claude Desktop.

Add `https://mcp.apify.com?tools=automation-lab/tradingview-community-ideas-strategy-scraper` to your MCP configuration.

For Claude Code, add the server with:

```bash
claude mcp add apify --transport http 'https://mcp.apify.com?tools=automation-lab/tradingview-community-ideas-strategy-scraper'
```

For a JSON MCP client configuration:

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

Example prompt: “Collect 20 public TradingView Ideas from this symbol page and summarize visible Long/Short direction by author.”

### How much does it cost to scrape TradingView Ideas?

The actor uses pay-per-event pricing: a small start event plus a per-record event.

Higher-volume tiers receive automatic discounts.

Check the actor’s live pricing panel before a production run because platform pricing is authoritative.

### Legality and responsible use

Collect only public data and comply with TradingView’s terms, robots guidance, and applicable law.

Do not use the output as financial advice or as a basis for automated trading execution.

Respect applicable data-protection and intellectual-property obligations.

### Troubleshooting: no records

Confirm the URL is public and opens in a logged-out browser.

Try the Ideas landing page first, then use a source URL copied from the public site.

A layout change or unavailable source can produce a warning with zero records.

### Troubleshooting: missing fields

Public card layouts vary by Idea and locale.

Fields such as direction, views, tags, and timeframe are optional and remain null or empty when not shown.

Enable detail enrichment for smaller collections when you need richer public metadata.

### FAQ: can I use a TradingView account?

No. This actor intentionally does not accept credentials or access private account data.

### FAQ: does it give trading advice?

No. It collects publicly visible content for research and content workflows.

### FAQ: can I monitor authors?

Yes. Submit a public TradingView author URL as a source and schedule a recurring run.

### Related scrapers

For public market-screening rows rather than community/editorial Ideas, see the [TradingView Scraper](https://apify.com/automation-lab/tradingview-scraper).

For a broader automation portfolio, browse [Automation Lab actors](https://apify.com/automation-lab).

### Support

Include the public source URL, run ID, and a small sample of expected public cards when reporting a parsing issue.

That helps distinguish a page-layout change from a source-specific availability problem.

# Actor input Schema

## `startUrls` (type: `array`):

Public TradingView Ideas feed, symbol, category, or author URLs. Only public tradingview.com URLs are accepted.

## `keyword` (type: `string`):

Optional public Ideas search phrase. Use a source URL for the most predictable collection.

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

Maximum public Idea records to save. Keep the first run small while validating a source.

## `enrichDetails` (type: `boolean`):

Visit each public Idea page for additional metadata when available. Slower than feed-only collection.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tradingview.com/ideas/"
    }
  ],
  "maxItems": 10,
  "enrichDetails": false
}
```

# Actor output Schema

## `defaultDataset` (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 = {
    "startUrls": [
        {
            "url": "https://www.tradingview.com/ideas/"
        }
    ],
    "keyword": "",
    "maxItems": 10,
    "enrichDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tradingview-community-ideas-strategy-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 = {
    "startUrls": [{ "url": "https://www.tradingview.com/ideas/" }],
    "keyword": "",
    "maxItems": 10,
    "enrichDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tradingview-community-ideas-strategy-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 '{
  "startUrls": [
    {
      "url": "https://www.tradingview.com/ideas/"
    }
  ],
  "keyword": "",
  "maxItems": 10,
  "enrichDetails": false
}' |
apify call automation-lab/tradingview-community-ideas-strategy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView Ideas & Strategy Scraper",
        "description": "📈 Turn public TradingView Ideas into a research-ready dataset of strategy notes, symbols, authors, engagement, and chart links.",
        "version": "0.1",
        "x-build-id": "fw3YilcC9UArg989J"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tradingview-community-ideas-strategy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tradingview-community-ideas-strategy-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-community-ideas-strategy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tradingview-community-ideas-strategy-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-community-ideas-strategy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tradingview-community-ideas-strategy-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": {
                    "startUrls": {
                        "title": "🔗 Public Ideas URLs",
                        "type": "array",
                        "description": "Public TradingView Ideas feed, symbol, category, or author URLs. Only public tradingview.com URLs are accepted.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keyword": {
                        "title": "🔎 Keyword (best effort)",
                        "type": "string",
                        "description": "Optional public Ideas search phrase. Use a source URL for the most predictable collection."
                    },
                    "maxItems": {
                        "title": "Maximum Ideas",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum public Idea records to save. Keep the first run small while validating a source.",
                        "default": 10
                    },
                    "enrichDetails": {
                        "title": "Enrich from public detail pages",
                        "type": "boolean",
                        "description": "Visit each public Idea page for additional metadata when available. Slower than feed-only collection.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```