# Stocktwits Scraper (`automation-lab/stocktwits-scraper`) Actor
Extract stock and crypto messages, bullish/bearish sentiment, trending symbols, and user posts from Stocktwits. Monitor market mood for any ticker. No API key needed.
- **URL**: https://apify.com/automation-lab/stocktwits-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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
## Stocktwits Scraper
Extract stock and crypto messages, **bullish/bearish sentiment**, trending symbols, and trader posts from [Stocktwits](https://stocktwits.com) — the largest financial social network for investors and traders. No API key or login required.
Monitor market mood for any ticker symbol in real time. Scrape the complete message stream for stocks like $AAPL or $TSLA, track what traders are saying about crypto like $BTC, or pull a ranked list of today's trending symbols — all in one actor.
### What does Stocktwits Scraper do?
Stocktwits Scraper connects to Stocktwits' internal API to extract messages, user profiles, and symbol data at scale. It covers four data modes:
- 📈 **Symbol stream** — all recent messages for any stock or crypto ticker (e.g., AAPL, TSLA, BTC.X, ETH.X)
- 👤 **User posts** — the complete message history of any public Stocktwits user
- 🔥 **Trending messages** — real-time feed of the most active discussions across all tickers
- 📊 **Trending symbols** — ranked list of the 30 most-discussed symbols with AI-generated summaries and fundamentals
Every message includes the full text, timestamp, **sentiment label** (Bullish or Bearish), mentioned tickers, user profile data, and attached chart or media URLs. Export to JSON, CSV, or Excel for downstream analysis.
### Who is Stocktwits Scraper for?
**Quant analysts and data scientists**
- Build trading signal models from retail investor sentiment
- Correlate Stocktwits sentiment with price movements using historical ticker data
- Create datasets for NLP and LLM fine-tuning on financial text
**Hedge funds and portfolio managers**
- Monitor crowd sentiment for positions in your portfolio
- Track how retail traders react to earnings, news events, or Fed announcements
- Identify unusual spikes in discussion volume for any ticker
**FinTech startups and research teams**
- Power sentiment dashboards and stock screeners with social signal data
- Monitor competitor tickers and compare community engagement
- Integrate with alternative data platforms (Bloomberg, Refinitiv, FactSet)
**Individual traders and retail investors**
- Track what top Stocktwits traders are saying about specific stocks
- Get a real-time pulse on market mood before opening a trade
- Automate daily sentiment reports for your watchlist
### Why use Stocktwits Scraper?
- 🚀 **Pure HTTP** — no browser overhead, extremely fast (100 messages in ~5 seconds)
- 💰 **16x cheaper compute** than the only competitor (256 MB vs 4096 MB)
- 📊 **Sentiment included** — every message that has a bullish/bearish label includes it
- 🔁 **Full pagination** — scrape hundreds of messages per ticker via cursor-based pagination
- 📦 **All 4 endpoints** — symbol, user, trending messages, and trending symbols
- 🤖 **AI-generated summaries** — trending symbols mode includes Stocktwits' own trend analysis
- 🌐 **No API key needed** — accesses the public data layer just like the browser does
- 🗂️ **Export-ready** — JSON, CSV, Excel, XML out of the box via Apify platform
### What data can you extract?
#### Message data (symbol, user, trending modes)
| Field | Type | Description |
|-------|------|-------------|
| `messageId` | number | Unique Stocktwits message ID |
| `body` | string | Full message text |
| `createdAt` | string | ISO 8601 timestamp |
| `sentiment` | string | "Bullish", "Bearish", or null |
| `symbols` | array | Ticker symbols mentioned (e.g., ["AAPL", "SPY"]) |
| `username` | string | Poster's Stocktwits username |
| `userName` | string | Poster's display name |
| `userId` | number | Poster's user ID |
| `userFollowers` | number | Follower count |
| `userFollowing` | number | Following count |
| `userIdeas` | number | Total messages posted |
| `userOfficial` | boolean | Whether it's a verified/official account |
| `userJoinDate` | string | Account creation date |
| `chartUrl` | string | Chart image URL (if attached) |
| `mediaUrl` | string | Media attachment URL (if attached) |
| `sourceTitle` | string | Source app (e.g., "StockTwits Web") |
| `url` | string | Direct link to the message |
| `scrapedAt` | string | Extraction timestamp |
#### Trending symbols data (trending-symbols mode)
| Field | Type | Description |
|-------|------|-------------|
| `symbol` | string | Ticker symbol (e.g., "AAPL") |
| `symbolDisplay` | string | Display ticker (e.g., "AAPL", "BTC") |
| `title` | string | Full company/asset name |
| `exchange` | string | Exchange (NASDAQ, NYSE, CRYPTO, etc.) |
| `instrumentClass` | string | Asset class (Stock, CRYPTO, etc.) |
| `logoUrl` | string | Symbol logo URL |
| `watchlistCount` | number | Number of users watching |
| `rank` | number | Trending rank (1 = most trending) |
| `trendingScore` | number | Quantitative trending score |
| `trendSummary` | string | AI-generated summary of why it's trending |
| `marketCap` | number | Market cap in billions (USD) |
| `sector` | string | GICS sector |
| `industry` | string | GICS industry |
| `scrapedAt` | string | Extraction timestamp |
### How much does it cost to scrape Stocktwits?
Stocktwits Scraper uses Pay-Per-Event (PPE) pricing — you only pay for what you extract.
| Plan | Price per message | Price per trending symbol |
|------|-------------------|--------------------------|
| Free | $0.0023 | $0.0023 |
| Starter (BRONZE) | $0.0020 | $0.0020 |
| Scale (SILVER) | $0.00156 | $0.00156 |
| Business (GOLD) | $0.0012 | $0.0012 |
**Real-world cost examples (BRONZE pricing):**
| What you're scraping | Items | Approx. cost |
|---------------------|-------|--------------|
| 50 AAPL messages | 50 | $0.10 |
| 100 TSLA messages | 100 | $0.20 |
| 30 trending symbols | 30 | $0.06 |
| 200 messages for 3 tickers | 600 | $1.20 |
**Free plan estimate:** With $5 in free credits you can extract approximately **2,000 messages** — enough for a full sentiment analysis run on your top 5 tickers.
There is also a small one-time start fee of $0.005 per run.
### How to scrape Stocktwits data
1. Go to [Stocktwits Scraper on Apify Store](https://apify.com/automation-lab/stocktwits-scraper)
2. Click **Try for free**
3. Select your **scraping mode** (symbol, user, trending, or trending-symbols)
4. Enter your **ticker symbols** (e.g., AAPL, TSLA, BTC.X) or **usernames**
5. Set **Max messages** (start with 20 to test)
6. Click **Start**
7. Download your results in JSON, CSV, or Excel
**Example input for symbol mode:**
```json
{
"mode": "symbol",
"symbols": ["AAPL", "TSLA", "BTC.X"],
"maxMessages": 100
}
````
**Example input for trending symbols:**
```json
{
"mode": "trending-symbols"
}
```
**Example input for user mode:**
```json
{
"mode": "user",
"usernames": ["jimcramer", "marketwizard"],
"maxMessages": 50
}
```
### Input parameters
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `symbol` | Scraping mode: `symbol`, `user`, `trending`, `trending-symbols` |
| `symbols` | array | `[]` | Ticker symbols to scrape (used in `symbol` mode). Crypto tickers end in `.X` |
| `usernames` | array | `[]` | Stocktwits usernames (used in `user` mode, without the @ sign) |
| `maxMessages` | integer | `100` | Max messages per symbol/user. Use `0` for all available |
| `proxyConfiguration` | object | BUYPROXIES | Proxy settings. Default datacenter proxy works well |
**Ticker format notes:**
- US stocks: `AAPL`, `TSLA`, `SPY`, `NVDA`
- Crypto: `BTC.X`, `ETH.X`, `DOGE.X` (note the `.X` suffix)
- ETFs: `QQQ`, `IWM`, `VTI`
### Output examples
**Message output (symbol/user/trending mode):**
```json
{
"messageId": 649367647,
"body": "$AAPL clean dip at the open → instant buyers stepped in → full intraday recovery. Bullish signal.",
"createdAt": "2026-04-03T07:14:06Z",
"sentiment": "Bullish",
"symbols": ["AAPL"],
"username": "TraderJoe",
"userName": "Joe Smith",
"userId": 10809273,
"userFollowers": 2500,
"userFollowing": 180,
"userIdeas": 1240,
"userOfficial": false,
"userJoinDate": "2021-01-15",
"chartUrl": null,
"mediaUrl": "https://media.stocktwits-cdn.com/api/3/media/11474646/default.webp",
"sourceTitle": "StockTwits Web",
"url": "https://stocktwits.com/TraderJoe/message/649367647",
"scrapedAt": "2026-04-03T09:26:27.791Z"
}
```
**Trending symbol output:**
```json
{
"symbol": "NVDA",
"symbolDisplay": "NVDA",
"title": "NVIDIA Corporation",
"exchange": "NASDAQ",
"instrumentClass": "Stock",
"logoUrl": "https://logos.stocktwits-cdn.com/NVDA.png",
"watchlistCount": 612450,
"rank": 1,
"trendingScore": 8.92,
"trendSummary": "NVIDIA is surging on AI chip demand with new data center orders announced. Community is heavily bullish ahead of earnings next week.",
"marketCap": 2810.5,
"sector": "Technology",
"industry": "Semiconductors",
"scrapedAt": "2026-04-03T09:26:54.370Z"
}
```
### Tips for best results
- 🎯 **Start small** — test with 20 messages per ticker to verify the output before scaling up
- 📅 **Use cursor pagination** — the actor handles multi-page scraping automatically; just set a high `maxMessages` value
- 💎 **Crypto tickers** — remember to add `.X` suffix: `BTC.X`, `ETH.X`, `SOL.X`, `DOGE.X`
- ⏰ **Schedule for market hours** — most discussion happens 9 AM–4 PM ET on weekdays
- 📊 **Sentiment analysis** — filter for `sentiment: "Bullish"` or `sentiment: "Bearish"` to build directional signal datasets
- 🔥 **Trending symbols first** — run `trending-symbols` mode daily to discover which tickers are getting unusual attention before scraping their message streams
### Integrations
**Stocktwits Scraper → Google Sheets via Zapier**
Monitor your portfolio tickers daily. Set up a Zapier workflow that runs the scraper on a schedule, then appends new messages with sentiment to a Google Sheet for manual review.
**Stocktwits → Slack alerts via Make**
Get notified when unusual discussion volume spikes on a ticker you follow. Create a Make scenario that runs the scraper hourly, counts messages, and sends a Slack alert when count exceeds a threshold.
**Scheduled sentiment tracking**
Use Apify Scheduler to run the scraper every morning at 8 AM ET before market open. Track the sentiment ratio (bullish/bearish) for your watchlist and feed the data to a Python analysis script via Apify API.
**Trending symbols → stock screener**
Combine `trending-symbols` mode with a stock screener API. Run this actor daily, extract the top 10 symbols, then look up their technical indicators to filter for high-probability setups.
**Webhook to database**
Configure an Apify webhook to POST new results directly to your database (Supabase, PostgreSQL, MongoDB) as soon as each run completes. Great for building real-time sentiment dashboards.
### Using the Apify API
#### Node.js
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('automation-lab/stocktwits-scraper').call({
mode: 'symbol',
symbols: ['AAPL', 'TSLA'],
maxMessages: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} messages`);
items.filter(m => m.sentiment === 'Bullish').forEach(m => {
console.log(`@${m.username}: ${m.body.slice(0, 80)}`);
});
```
#### Python
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/stocktwits-scraper").call(run_input={
"mode": "symbol",
"symbols": ["AAPL", "TSLA"],
"maxMessages": 100,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
bullish = [m for m in items if m.get("sentiment") == "Bullish"]
bearish = [m for m in items if m.get("sentiment") == "Bearish"]
print(f"Bullish: {len(bullish)}, Bearish: {len(bearish)}, Neutral: {len(items)-len(bullish)-len(bearish)}")
```
#### cURL
```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~stocktwits-scraper/runs?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"mode": "symbol",
"symbols": ["AAPL", "TSLA"],
"maxMessages": 50
}'
```
### Use with AI agents via MCP
Stocktwits Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).
Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:
#### Setup for Claude Code
```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```
#### Setup for Claude Desktop, Cursor, or VS Code
Add this to your MCP config file:
```json
{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com"
}
}
}
```
Your AI assistant will use OAuth to authenticate with your Apify account on first use.
#### Example prompts
Once connected, try asking your AI assistant:
- "Use automation-lab/stocktwits-scraper to get the last 50 messages for NVDA and summarize the sentiment"
- "Fetch the trending symbols from Stocktwits right now and tell me which sectors are getting the most attention"
- "Get 100 messages for BTC.X from Stocktwits and count how many are bullish vs bearish"
Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).
### Is it legal to scrape Stocktwits?
Stocktwits is a publicly accessible social platform. All data extracted by this actor is publicly visible in a browser without logging in. This actor:
- Only accesses **public content** — no authentication, no private messages
- Does **not** bypass any authentication or paywall
- Respects rate limits and includes delays between requests
- Complies with GDPR in that all extracted data is publicly available
Use the data responsibly: for market research, academic study, sentiment analysis, and trading signal research. Do not use it to spam, harass, or build contact databases. Always review [Stocktwits' Terms of Service](https://stocktwits.com/terms) for your specific use case.
Apify is committed to ethical scraping — we only build tools for publicly accessible data and promote responsible data use. See [Apify's Legal page](https://apify.com/legal) for more details.
### FAQ
**How fast is Stocktwits Scraper?**
Very fast. The actor uses pure HTTP requests (no browser), so it can extract 100 messages in approximately 5–10 seconds on a typical run, depending on the number of pagination pages needed.
**How much does it cost to scrape 1,000 messages?**
At BRONZE pricing ($0.002/message), 1,000 messages costs $2.00 plus a $0.005 run start fee. On the free plan ($5 credits) you can extract approximately 2,100 messages.
**Does it work for crypto tickers?**
Yes. Use the `.X` suffix for crypto: `BTC.X`, `ETH.X`, `SOL.X`, `DOGE.X`, `ADA.X`, etc. The trending-symbols mode includes both stocks and crypto.
**What's the difference between Stocktwits Scraper and the official Stocktwits API?**
The official Stocktwits API requires an approved developer account and has strict rate limits. This scraper uses the same public API endpoints your browser accesses, requiring no API key or login.
**Why are some messages missing sentiment?**
Sentiment on Stocktwits is user-provided — traders manually mark their message as Bullish or Bearish when posting. Many users don't add a sentiment label, so those messages return `null` for the `sentiment` field. In practice, roughly 30–50% of messages have sentiment labels.
**Why did I get zero results?**
- Check the ticker format: crypto needs `.X` (e.g., `BTC.X` not `BTC`)
- Verify the symbol exists on Stocktwits — search for it at stocktwits.com
- Try the `trending-symbols` mode to discover valid tickers
- If a username returns nothing, verify it exists on Stocktwits
**What if the scraper gets blocked?**
The actor uses Apify's datacenter proxies by default, which work reliably with Stocktwits. If you experience blocks, you can switch to the RESIDENTIAL proxy group in the Proxy configuration setting.
### Other financial scrapers
- [Yahoo Finance Scraper](https://apify.com/automation-lab/yahoo-finance-scraper) — stock prices, charts, historical data
- [TradingView Scraper](https://apify.com/automation-lab/tradingview-scraper) — stock screener with technical indicators
- [CoinGecko Scraper](https://apify.com/automation-lab/coingecko-scraper) — crypto prices, market caps, coin data
- [CoinMarketCap Scraper](https://apify.com/automation-lab/coinmarketcap-scraper) — crypto market data
- [DexScreener Scraper](https://apify.com/automation-lab/dexscreener-scraper) — decentralized exchange token data
- [Financial Statements Scraper](https://apify.com/automation-lab/financial-statements-scraper) — SEC filings, income statements
- [Reddit Scraper](https://apify.com/automation-lab/reddit-scraper) — Reddit posts and comments for r/wallstreetbets and other finance subreddits
# Actor input Schema
## `mode` (type: `string`):
Select what to scrape:
symbol — messages for specific stock/crypto tickers (e.g., AAPL, TSLA)
user — posts from specific Stocktwits users
trending — trending messages across all symbols
trending-symbols — list of currently trending symbols with AI summaries
## `symbols` (type: `array`):
Enter ticker symbols to scrape (e.g., AAPL, TSLA, BTC.X, ETH.X). Use the symbol mode. Crypto tickers end in .X.
## `usernames` (type: `array`):
Enter Stocktwits usernames to scrape (without the @ sign). Used in user mode.
## `maxMessages` (type: `integer`):
Maximum number of messages to extract per symbol or user. Use 0 for unlimited (up to API limits). Keep low for quick tests.
## `proxyConfiguration` (type: `object`):
Proxy settings for bypassing Cloudflare protection. The default datacenter proxy works well; switch to residential if you encounter blocks.
## Actor input object example
```json
{
"mode": "symbol",
"symbols": [
"AAPL",
"TSLA"
],
"usernames": [
"jimcramer"
],
"maxMessages": 20,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyGroups": [
"BUYPROXIES94952"
]
}
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"mode": "symbol",
"symbols": [
"AAPL",
"TSLA"
],
"usernames": [
"jimcramer"
],
"maxMessages": 20
};
// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/stocktwits-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"mode": "symbol",
"symbols": [
"AAPL",
"TSLA",
],
"usernames": ["jimcramer"],
"maxMessages": 20,
}
# Run the Actor and wait for it to finish
run = client.actor("automation-lab/stocktwits-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 '{
"mode": "symbol",
"symbols": [
"AAPL",
"TSLA"
],
"usernames": [
"jimcramer"
],
"maxMessages": 20
}' |
apify call automation-lab/stocktwits-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=automation-lab/stocktwits-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Stocktwits Scraper",
"description": "Extract stock and crypto messages, bullish/bearish sentiment, trending symbols, and user posts from Stocktwits. Monitor market mood for any ticker. No API key needed.",
"version": "0.1",
"x-build-id": "3oauQyz42l2d7hLm7"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/automation-lab~stocktwits-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-automation-lab-stocktwits-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~stocktwits-scraper/runs": {
"post": {
"operationId": "runs-sync-automation-lab-stocktwits-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~stocktwits-scraper/run-sync": {
"post": {
"operationId": "run-sync-automation-lab-stocktwits-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",
"required": [
"mode"
],
"properties": {
"mode": {
"title": "🎯 Scraping mode",
"enum": [
"symbol",
"user",
"trending",
"trending-symbols"
],
"type": "string",
"description": "Select what to scrape:
symbol — messages for specific stock/crypto tickers (e.g., AAPL, TSLA)
user — posts from specific Stocktwits users
trending — trending messages across all symbols
trending-symbols — list of currently trending symbols with AI summaries",
"default": "symbol"
},
"symbols": {
"title": "Stock/crypto symbols",
"type": "array",
"description": "Enter ticker symbols to scrape (e.g., AAPL, TSLA, BTC.X, ETH.X). Use the symbol mode. Crypto tickers end in .X.",
"default": [],
"items": {
"type": "string"
}
},
"usernames": {
"title": "Stocktwits usernames",
"type": "array",
"description": "Enter Stocktwits usernames to scrape (without the @ sign). Used in user mode.",
"default": [],
"items": {
"type": "string"
}
},
"maxMessages": {
"title": "Max messages",
"minimum": 1,
"maximum": 10000,
"type": "integer",
"description": "Maximum number of messages to extract per symbol or user. Use 0 for unlimited (up to API limits). Keep low for quick tests.",
"default": 100
},
"proxyConfiguration": {
"title": "🔒 Proxy configuration",
"type": "object",
"description": "Proxy settings for bypassing Cloudflare protection. The default datacenter proxy works well; switch to residential if you encounter blocks.",
"default": {
"useApifyProxy": true,
"apifyProxyGroups": [
"BUYPROXIES94952"
]
}
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```