# Myfxbook Community Outlook / Retail Sentiment Scraper (`xtracto/myfxbook-community-outlook`) Actor

HTTP-only scraper for Myfxbook's Community Outlook (retail forex sentiment): short/long volume %, average short/long entry prices, trapped volume in lots, and open-position counts for ~70+ symbols. Contrarian/SMC liquidity signal.

- **URL**: https://apify.com/xtracto/myfxbook-community-outlook.md
- **Developed by:** [Xtractoo](https://apify.com/xtracto) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $15.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Myfxbook Community Outlook / Retail Sentiment Scraper

Extract **live retail forex sentiment** from Myfxbook's Community Outlook — the short vs
long positioning of thousands of real traders across 70+ currency pairs, metals, and crosses
— as clean, structured JSON.

Retail positioning is widely used as a **contrarian signal**: when the crowd is heavily long,
price often hunts the liquidity sitting under their average entry. This actor turns that
crowd data into a feed you can plug straight into a strategy, dashboard, or database.

### Why use this actor

- **No account, no login, no API key required** — it reads the public Community Outlook.
- **Complete sentiment per symbol** — short %, long %, average short/long entry prices, trapped volume (lots), and open-position counts.
- **All symbols in one run** — 70+ pairs/metals fetched together, typically in a single fast request.
- **Stable JSON output** — ready for pipelines, databases, spreadsheets, or backtests (download as JSON, CSV, or Excel).
- **Automatic retries** — transient hiccups are retried for you; no scrapers or browsers to manage.
- **Optional symbol filter** — pull just the pairs you trade (e.g. `EURUSD`, `XAUUSD`).

### How it works

1. (Optional) You list the symbols you care about — or leave it empty to get every symbol.
2. The actor fetches the current Community Outlook and reads each symbol's crowd positioning: how many traders are short vs long, the volume behind each side, and their average entry prices.
3. Each symbol becomes one record and streams into your dataset, ready to download or feed into your tools.

You don't manage browsers, sessions, or retries — just run it (on demand or on a schedule) and read the results.

### Use Cases

**Contrarian / Smart Money trading signal**
Build an automated feed that alerts when retail is >70% long on a pair — a classic liquidity-hunt setup. Pull the data every 15 minutes, compare it against your price-action model, and trigger entry signals where the crowd's average entry sits above current price (short-trap zones).

**Algorithmic strategy backtesting**
Schedule the actor hourly and store every run in a time-series database. Reconstruct how retail positioning evolved before and after major moves on EURUSD, XAUUSD, or any other pair — and validate whether high-lopsidedness reliably preceded reversals.

**Real-time trading dashboard**
Wire the actor into a Grafana or Retool dashboard that shows the short/long split, trapped-lot volumes, and distance-from-price for every symbol at a glance — a live "liquidity map" your desk can read in seconds.

**Risk management & position sizing**
Before entering a trade, check whether retail is crowded in the same direction. If `tradersTradingPercentage` is high and the crowd is aligned with your thesis, scale down — you may be on the same side as the stop-hunt target.

**Academic / quant research**
Compile months of daily snapshots to study the predictive power of retail sentiment across different market regimes, asset classes (forex vs. gold vs. crypto-adjacent pairs), and volatility environments.

### Input

```json
{
  "symbols": ["EURUSD", "XAUUSD"],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Field | Type | Description |
|---|---|---|
| `symbols` | array | Optional whitelist of symbols (case-insensitive), e.g. `["EURUSD","XAUUSD"]`. **Leave empty to scrape all symbols.** |
| `proxyConfiguration` | object | Proxy settings. Residential is recommended for reliable, geo-stable results. |

> Tip: leave `symbols` empty and run on a schedule (Myfxbook refreshes roughly every ~15 minutes) to keep a rolling sentiment history.

### Output

Each symbol produces one record. Real sample output:

```json
{
  "_input": "https://www.myfxbook.com/community/outlook",
  "_source": "S1-html",
  "_scrapedAt": "2026-05-29T06:28:42Z",
  "symbol": "EURUSD",
  "symbolId": 1,
  "decimals": 5,
  "shortPercentage": 41.0,
  "longPercentage": 59.0,
  "shortVolumeLots": 7765.33,
  "longVolumeLots": 11365.74,
  "shortPositions": 28378,
  "longPositions": 32410,
  "totalPositions": 60788,
  "totalVolumeLots": 19131.07,
  "avgShortPrice": 1.1406,
  "avgLongPrice": 1.1682,
  "shortDistancePips": -241,
  "longDistancePips": -35,
  "currentPrice": 1.1647,
  "popularityPercentage": 50.0,
  "tradersTradingPercentage": 33.0,
  "trendShortPercentage": 41.0,
  "trendLongPercentage": 59.0
}
```

A metals example (`XAUUSD`):

```json
{
  "symbol": "XAUUSD",
  "shortPercentage": 48.0,
  "longPercentage": 52.0,
  "shortVolumeLots": 1245.28,
  "longVolumeLots": 1352.66,
  "shortPositions": 7749,
  "longPositions": 10617,
  "totalPositions": 18366,
  "avgShortPrice": 4292.4978,
  "avgLongPrice": 4604.0433,
  "currentPrice": 4520.23,
  "shortDistancePips": -22773,
  "longDistancePips": -8381
}
```

| Field | Type | Description |
|---|---|---|
| `symbol` | string | Trading symbol (e.g. `EURUSD`, `XAUUSD`). |
| `shortPercentage` | number | Percentage of volume positioned **short**. |
| `longPercentage` | number | Percentage of volume positioned **long**. |
| `avgShortPrice` | number | Average entry price of short positions. |
| `avgLongPrice` | number | Average entry price of long positions. |
| `shortPositions` | integer | Number of open short positions. |
| `longPositions` | integer | Number of open long positions. |
| `totalPositions` | integer | Total open positions (short + long). |
| `shortVolumeLots` | number | Volume held short, in lots. |
| `longVolumeLots` | number | Volume held long, in lots. |
| `totalVolumeLots` | number | Total volume, in lots (short + long). |
| `shortDistancePips` | integer | Distance of the average short entry from the current price, in pips. |
| `longDistancePips` | integer | Distance of the average long entry from the current price, in pips. |
| `currentPrice` | number | Current market price. |
| `popularityPercentage` | number | How popular the symbol is among the community. |
| `tradersTradingPercentage` | number | Share of traders currently trading this symbol. |
| `trendShortPercentage` / `trendLongPercentage` | number | Short/long split shown on the trend bar (mirrors `shortPercentage` / `longPercentage`). |
| `symbolId` | integer | Myfxbook's internal symbol id. |
| `decimals` | integer | Price decimal places for the symbol. |
| `_input` | string | The source the record came from. |
| `_source` | string | Extraction strategy tag. |
| `_scrapedAt` | string | UTC timestamp (ISO 8601) when the record was captured. |

If a run cannot retrieve data, a single record with an `_error` field is written instead (so failures are never silent).

### Notes & limits

- The Community Outlook reflects Myfxbook's connected community and updates roughly every ~15 minutes — schedule the actor accordingly.
- Percentages are rounded by the source, so short + long may occasionally total 99–101%.
- This actor reads only the **public** outlook (no account-only data).

# Actor input Schema

## `symbols` (type: `array`):

Restrict output to these symbols (e.g. EURUSD, XAUUSD). Leave empty to scrape ALL symbols on the outlook page.

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

Residential proxy is recommended for reliable, geo-stable results. For light use the data is public and may work without a proxy.

## Actor input object example

```json
{
  "symbols": [
    "EURUSD",
    "XAUUSD"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "symbols": [
        "EURUSD",
        "XAUUSD"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/myfxbook-community-outlook").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 = { "symbols": [
        "EURUSD",
        "XAUUSD",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("xtracto/myfxbook-community-outlook").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 '{
  "symbols": [
    "EURUSD",
    "XAUUSD"
  ]
}' |
apify call xtracto/myfxbook-community-outlook --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=xtracto/myfxbook-community-outlook",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Myfxbook Community Outlook / Retail Sentiment Scraper",
        "description": "HTTP-only scraper for Myfxbook's Community Outlook (retail forex sentiment): short/long volume %, average short/long entry prices, trapped volume in lots, and open-position counts for ~70+ symbols. Contrarian/SMC liquidity signal.",
        "version": "0.1",
        "x-build-id": "xLGhuQ7RBafKhEovE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~myfxbook-community-outlook/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-myfxbook-community-outlook",
                "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/xtracto~myfxbook-community-outlook/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-myfxbook-community-outlook",
                "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/xtracto~myfxbook-community-outlook/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-myfxbook-community-outlook",
                "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": {
                    "symbols": {
                        "title": "Symbols filter (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict output to these symbols (e.g. EURUSD, XAUUSD). Leave empty to scrape ALL symbols on the outlook page.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended for reliable, geo-stable results. For light use the data is public and may work without a proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
