# X (Twitter) Bulk Scraper/Monitor/Alerts + Vision (`dubz/x-bulk-vision`) Actor

Monitor X (formerly Twitter) for specific content. Extract data, monitor, and optionally run image-based alerts using cloud vision APIs. Perfect for brand reputation management, tracking tweets, hashtags, specific images, and user activity.

- **URL**: https://apify.com/dubz/x-bulk-vision.md
- **Developed by:** [⠀Advanced Automation](https://apify.com/dubz) (community)
- **Categories:** Automation, Social media, AI
- **Stats:** 9 total users, 2 monthly users, 0.0% runs succeeded, 0 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

## X (Twitter) Bulk Scrape/Monitor + Vision AI

Monitor X/Twitter accounts, extract tweets, filter by keywords/hashtags, and run AI vision analysis on images using 6 different AI providers.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue)](https://apify.com)
[![Node.js](https://img.shields.io/badge/Node.js-18-green)](https://nodejs.org)
[![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)

### 🎯 Overview

This Apify Actor scrapes X (formerly Twitter) posts from multiple accounts, filters by keywords/hashtags, and optionally runs AI vision analysis on images to detect objects, brands, or custom content patterns. Perfect for social media monitoring, brand tracking, and competitive intelligence.

### ✨ Key Features

#### Core Scraping
- 🚀 **Hyperdrive Mode**: Lightning-fast RSS-based scraping with automatic fallback to web scraping
- 👥 **Bulk Processing**: Monitor up to 100 Twitter accounts simultaneously
- 🔍 **Smart Filtering**: Filter by keywords, hashtags, or require images
- 📊 **Dual Datasets**: Separate outputs for tweets and vision alerts
- 🔄 **Automatic Retry**: Robust error handling with multiple Nitter instance fallbacks

#### AI Vision Analysis (Optional)
Analyze tweet images using 6 industry-leading AI providers:

- 🤖 **Google Gemini 2.0 Flash** - Latest multimodal AI with base64 encoding
- 🎨 **OpenAI GPT-4o Vision** - Advanced image understanding and analysis
- 👁️ **Google Cloud Vision** - Label detection, OCR, safe search, object localization
- ☁️ **Azure Computer Vision** - Tags, objects, brands, faces, adult content detection
- 📸 **AWS Rekognition** - Label detection and content moderation
- 🔗 **Custom Webhooks** - Integrate your own vision API

#### Alert System
- 🔔 **Webhook Notifications**: Get instant alerts when vision pipelines trigger
- 🎯 **Flexible Configuration**: Per-pipeline or global webhook URLs
- 📈 **Confidence Scoring**: Filter alerts by AI confidence thresholds
- 🏷️ **Label Matching**: Trigger on specific detected objects or keywords

### 📥 Input Configuration

#### Basic Example

```json
{
  "usernames": ["apify", "openai"],
  "maxItems": 100,
  "preferRss": true
}
````

#### Complete Example with Vision Analysis

```json
{
  "usernames": ["apify", "elonmusk", "openai"],
  "searchTerms": ["AI", "automation", "web scraping"],
  "hashtags": ["webscraping", "machinelearning"],
  "maxItems": 500,
  "preferRss": true,
  "requireImages": false,
  "rssTimeoutSecs": 10,
  "visionPipelines": [
    {
      "name": "Product Launch Detector",
      "provider": "gemini_vision",
      "enabled": true,
      "configJson": "{\"prompt\":\"Is this a product launch or announcement?\",\"triggerKeywords\":[\"launch\",\"new\",\"announcement\"],\"model\":\"gemini-2.0-flash-exp\"}",
      "alertWebhookUrl": "https://your-webhook.com/product-alerts"
    },
    {
      "name": "Brand Monitor",
      "provider": "openai_vision",
      "enabled": true,
      "configJson": "{\"prompt\":\"Identify brands and logos\",\"triggerKeywords\":[\"Tesla\",\"Apple\",\"Nike\"],\"model\":\"gpt-4o\"}",
      "alertWebhookUrl": ""
    },
    {
      "name": "Object Detector",
      "provider": "google_vision",
      "enabled": true,
      "configJson": "{\"threshold\":0.8,\"triggerLabels\":[\"car\",\"vehicle\"],\"maxLabels\":10}"
    }
  ]
}
```

#### Input Fields

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `usernames` | array | ✅ Yes | X/Twitter usernames to monitor (without @ symbol) |
| `searchTerms` | array | No | Filter tweets containing these keywords |
| `hashtags` | array | No | Filter tweets containing these hashtags |
| `maxItems` | integer | No | Maximum tweets to collect (default: 100) |
| `preferRss` | boolean | No | Use RSS scraping first (default: true) |
| `requireImages` | boolean | No | Only collect tweets with images (default: false) |
| `rssTimeoutSecs` | integer | No | RSS fetch timeout in seconds (default: 10) |
| `visionPipelines` | array | No | AI vision analysis configuration |

#### Vision Pipeline Configuration

Each pipeline in `visionPipelines` array:

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `name` | string | ✅ Yes | Descriptive name for the pipeline |
| `provider` | string | ✅ Yes | AI provider: `gemini_vision`, `openai_vision`, `google_vision`, `azure_cv`, `aws_rekognition`, `custom_webhook` |
| `enabled` | boolean | No | Enable/disable this pipeline (default: true) |
| `configJson` | string | No | Provider-specific configuration as JSON string |
| `alertWebhookUrl` | string | No | Webhook URL for alerts (overrides env var) |

#### Provider-Specific Configuration

##### Gemini Vision

```json
{
  "prompt": "Describe what you see in detail",
  "triggerKeywords": ["product", "launch"],
  "model": "gemini-2.0-flash-exp"
}
```

##### OpenAI Vision

```json
{
  "prompt": "Identify brands and logos",
  "triggerKeywords": ["Nike", "Apple"],
  "model": "gpt-4o",
  "maxTokens": 500
}
```

##### Google Cloud Vision

```json
{
  "threshold": 0.8,
  "triggerLabels": ["car", "vehicle"],
  "maxLabels": 10
}
```

##### Azure Computer Vision

```json
{
  "minConfidence": 0.7,
  "targetTags": ["car", "person"],
  "blockAdult": false
}
```

##### AWS Rekognition

```json
{
  "minConfidence": 0.7,
  "targetLabels": ["Car", "Person"],
  "blockUnsafe": true
}
```

##### Custom Webhook

```json
{
  "webhookUrl": "https://your-api.com/analyze",
  "timeout": 20000,
  "headers": {
    "Authorization": "Bearer YOUR_TOKEN"
  }
}
```

### 📤 Output

#### Main Dataset (Tweets)

Each scraped tweet contains:

```json
{
  "title": "Check out our new Actor for web scraping!",
  "link": "https://x.com/apify/status/1234567890",
  "author": "apify",
  "published": "2026-01-15T10:30:00Z",
  "description": "Check out our new Actor...",
  "tags": ["#webscraping", "#automation"],
  "imageUrl": "https://pbs.twimg.com/media/abc123.jpg",
  "visionAlertsCount": 2,
  "scrapedUsername": "apify",
  "collectedAt": "2026-01-15T10:35:00Z",
  "sourceType": "rss",
  "instance": "nitter.net"
}
```

#### Alerts Dataset (Vision Triggers)

Each triggered alert contains:

```json
{
  "pipelineName": "Product Launch Detector",
  "provider": "gemini_vision",
  "itemLink": "https://x.com/apify/status/1234567890",
  "imageUrl": "https://pbs.twimg.com/media/abc123.jpg",
  "labels": [
    {"name": "product", "score": 0.95},
    {"name": "announcement", "score": 0.88}
  ],
  "score": 0.95,
  "analysis": "This image shows a new product launch announcement...",
  "triggeredAt": "2026-01-15T10:35:00Z"
}
```

#### Output Views

The Actor provides multiple pre-configured output views:

- **tweets** - Full dataset JSON
- **tweetsTable** - Simplified table view
- **tweetsCSV** - CSV export
- **tweetsWithImages** - Images only
- **visionAlerts** - All vision alerts
- **visionAlertsTable** - Simplified alerts view
- **visionAlertsCSV** - Alerts CSV export
- **highConfidenceAlerts** - 90%+ confidence only
- **runStats** - Actor run statistics

### 🔐 Environment Variables

Configure AI providers via environment variables in the Actor settings:

#### Required (if using vision analysis)

| Variable | Description | Example |
|----------|-------------|---------|
| `OPENAI_API_KEY` | OpenAI API key for GPT-4o Vision | `sk-...` |
| `GEMINI_API_KEY` | Google Gemini API key | `AIza...` |
| `GOOGLE_APPLICATION_CREDENTIALS` | Google Cloud credentials JSON | `{"type":"service_account",...}` |
| `AZURE_CV_ENDPOINT` | Azure Computer Vision endpoint | `https://your-resource.cognitiveservices.azure.com/` |
| `AZURE_CV_KEY` | Azure Computer Vision API key | `abc123...` |
| `AWS_ACCESS_KEY_ID` | AWS access key for Rekognition | `AKIA...` |
| `AWS_SECRET_ACCESS_KEY` | AWS secret key | `abc123...` |
| `AWS_REGION` | AWS region (optional) | `us-east-1` (default) |

#### Optional

| Variable | Description |
|----------|-------------|
| `ALERT_WEBHOOK_URL` | Global webhook URL for all alerts |
| `WEBHOOK_<PIPELINE_NAME>` | Pipeline-specific webhook (e.g., `WEBHOOK_PRODUCT_DETECTOR`) |

#### Setting Environment Variables

**Via Apify Console:**

1. Go to your Actor → Settings → Environment variables
2. Click "Add variable"
3. Enter name and value
4. Check "Secret" for sensitive data

**Via .actor/actor.json:**

```json
{
  "environmentVariables": {
    "OPENAI_API_KEY": "@openai-key",
    "GEMINI_API_KEY": "@gemini-key"
  }
}
```

Note: Use `@secret-name` syntax to reference Apify secrets.

### 🎯 Use Cases

#### 1. Brand Monitoring

Monitor brand mentions and visual content across competitor accounts:

- Track logo appearances in images
- Detect product placements
- Monitor sentiment around brand discussions

#### 2. Product Launch Detection

Get instant alerts when competitors announce new products:

- Analyze images for product unveils
- Detect "new" or "launching" keywords
- Track announcement patterns

#### 3. Content Moderation

Filter and flag inappropriate content:

- Adult content detection (Azure/AWS)
- Unsafe content filtering
- Brand safety monitoring

#### 4. Competitor Analysis

Track competitor social media activity:

- Monitor posting frequency
- Analyze content themes
- Track image-based campaigns

#### 5. Social Media Intelligence

Aggregate insights from multiple accounts:

- Trending topics detection
- Hashtag performance tracking
- Engagement pattern analysis

#### 6. Market Research

Gather visual data for market analysis:

- Product feature comparisons
- Packaging design trends
- Campaign creative analysis

### 🚀 Quick Start

#### 1. Basic Tweet Scraping (No Vision)

```json
{
  "usernames": ["apify"],
  "maxItems": 50
}
```

#### 2. Keyword Filtering

```json
{
  "usernames": ["techcrunch", "theverge"],
  "searchTerms": ["AI", "ChatGPT"],
  "maxItems": 100
}
```

#### 3. Image-Only Collection

```json
{
  "usernames": ["nasa", "spacex"],
  "requireImages": true,
  "maxItems": 50
}
```

#### 4. With Gemini Vision

```json
{
  "usernames": ["producthunt"],
  "requireImages": true,
  "visionPipelines": [{
    "name": "Product Detector",
    "provider": "gemini_vision",
    "enabled": true,
    "configJson": "{\"prompt\":\"Describe this product\",\"triggerKeywords\":[\"app\",\"software\"]}"
  }]
}
```

### 📊 Performance & Limits

- **Speed**: 50-100 tweets per minute (RSS mode)
- **Concurrent Accounts**: Up to 100 usernames
- **Vision Processing**: ~2-5 seconds per image per provider
- **Memory**: 512MB recommended (1GB for heavy vision usage)
- **Timeout**: 300 seconds default (adjust in Actor settings)

### 🔧 Troubleshooting

#### No Items Collected

**Possible causes:**

- Bot protection blocking Nitter instances
- Invalid usernames
- User accounts have no recent posts
- Filters are too restrictive

**Solutions:**

- Verify usernames are correct (without @ symbol)
- Try different time of day
- Reduce filter restrictions
- Check Actor logs for specific errors

#### Vision Analysis Not Working

**Possible causes:**

- Missing API credentials in environment variables
- Invalid API keys
- API rate limits exceeded
- Image URLs inaccessible

**Solutions:**

- Verify all required environment variables are set
- Check API key validity in provider dashboard
- Review Actor logs for specific API errors
- Ensure images are publicly accessible

#### Webhook Alerts Not Received

**Possible causes:**

- Invalid webhook URL
- Webhook endpoint timeout
- Firewall blocking Apify IPs

**Solutions:**

- Test webhook URL with curl/Postman
- Increase webhook timeout in config
- Verify webhook endpoint accepts POST requests
- Check webhook logs for incoming requests

### 🏗️ Architecture

#### Data Flow

1. **Input Validation** - Verify usernames and configuration
2. **Instance Discovery** - Fetch working Nitter instances from status page
3. **RSS Scraping** - Try RSS feeds from multiple instances
4. **Web Scraping Fallback** - Parse HTML if RSS fails
5. **Content Filtering** - Apply keyword/hashtag filters
6. **Vision Processing** - Run enabled AI pipelines on images
7. **Alert Triggering** - Send webhooks for matched patterns
8. **Data Storage** - Save to Apify datasets

#### Technical Stack

- **Runtime**: Node.js 18 (Apify SDK 3.x)
- **HTTP Client**: Axios
- **HTML Parsing**: Cheerio
- **RSS Parsing**: rss-parser
- **AI Providers**: Native REST APIs
- **Image Processing**: Base64 encoding for Gemini/OpenAI

### 📝 Changelog

#### Version 1.0.0 (2026-02-01)

- ✨ Initial release
- 🚀 RSS-first scraping with web fallback
- 🤖 6 AI vision providers
- 🔔 Webhook alert system
- 📊 Dual dataset output

### 📄 License

Apache-2.0

### 🆘 Support & Resources

- 📚 [Apify Documentation](https://docs.apify.com)
- 💬 [Apify Discord Community](https://discord.com/invite/jyEM2PRvMU)
- 🐛 [Report Issues](https://github.com/your-repo/issues)
- 💡 [Feature Requests](https://github.com/your-repo/discussions)
- 📧 [Contact Support](https://apify.com/contact)

### 🙏 Credits

Built with ❤️ using:

- [Apify Platform](https://apify.com)
- [Nitter](https://github.com/zedeus/nitter) instances
- [OpenAI](https://openai.com) GPT-4o Vision
- [Google Gemini](https://deepmind.google/technologies/gemini/)
- [Google Cloud Vision](https://cloud.google.com/vision)
- [Azure Computer Vision](https://azure.microsoft.com/en-us/services/cognitive-services/computer-vision/)
- [AWS Rekognition](https://aws.amazon.com/rekognition/)

***

**Made by \[dubz]**

# Actor input Schema

## `usernames` (type: `array`):

List of X/Twitter usernames to monitor (without @ symbol). Example: 'apify', 'elonmusk'

## `searchTerms` (type: `array`):

Filter tweets containing these keywords or phrases. Leave empty to collect all tweets.

## `hashtags` (type: `array`):

Filter tweets containing these hashtags (with or without # symbol).

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

Maximum number of tweets to collect across all usernames.

## `preferRss` (type: `boolean`):

If enabled, use optimized hypderdrive scraping and only fall back to web scraping when needed (recommended).

## `requireImages` (type: `boolean`):

If enabled, items without image URLs will be filtered out.

## `rssTimeoutSecs` (type: `integer`):

Timeout for Hyperdrive feed/post fetching (in seconds).

## `visionPipelinesJson` (type: `string`):

Paste full JSON array of vision pipeline configurations. See README for examples. Leave empty to skip vision processing.

## Actor input object example

```json
{
  "usernames": [
    "apify"
  ],
  "searchTerms": [
    "OpenAI",
    "Apify"
  ],
  "hashtags": [
    "webscraping",
    "automation"
  ],
  "maxItems": 100,
  "preferRss": true,
  "requireImages": false,
  "rssTimeoutSecs": 10,
  "visionPipelinesJson": "[\n  {\n    \"name\": \"Gemini Product Detector\",\n    \"provider\": \"gemini_vision\",\n    \"enabled\": false,\n    \"configJson\": \"{\\\"prompt\\\":\\\"Is this a product launch?\\\",\\\"triggerKeywords\\\":[\\\"launch\\\",\\\"new\\\"]}\",\n    \"alertWebhookUrl\": \"\"\n  }\n]"
}
```

# Actor output Schema

## `tweets` (type: `string`):

All scraped tweets with metadata, images, and vision analysis counts. Default dataset containing complete tweet information.

## `tweetsTable` (type: `string`):

Table view of scraped tweets with key fields for quick overview.

## `tweetsCSV` (type: `string`):

Export all tweets to CSV format for spreadsheet analysis.

## `tweetsWithImages` (type: `string`):

Filtered view showing only tweets that contain images.

## `visionAlerts` (type: `string`):

All triggered vision pipeline alerts from AI analysis. Separate dataset containing matched labels, confidence scores, and analysis results.

## `visionAlertsTable` (type: `string`):

Simplified table view of vision alerts with key detection information.

## `visionAlertsCSV` (type: `string`):

Export vision alerts to CSV format.

## `highConfidenceAlerts` (type: `string`):

Vision alerts with confidence score of 0.9 or higher.

## `runStats` (type: `string`):

Summary statistics from the Actor run including item counts and processed users.

# 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 = {
    "usernames": [
        "apify"
    ],
    "searchTerms": [
        "OpenAI",
        "Apify"
    ],
    "hashtags": [
        "webscraping",
        "automation"
    ],
    "visionPipelinesJson": `[
  {
    "name": "Gemini Product Detector",
    "provider": "gemini_vision",
    "enabled": false,
    "configJson": "{\"prompt\":\"Is this a product launch?\",\"triggerKeywords\":[\"launch\",\"new\"]}",
    "alertWebhookUrl": ""
  }
]`
};

// Run the Actor and wait for it to finish
const run = await client.actor("dubz/x-bulk-vision").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 = {
    "usernames": ["apify"],
    "searchTerms": [
        "OpenAI",
        "Apify",
    ],
    "hashtags": [
        "webscraping",
        "automation",
    ],
    "visionPipelinesJson": """[
  {
    \"name\": \"Gemini Product Detector\",
    \"provider\": \"gemini_vision\",
    \"enabled\": false,
    \"configJson\": \"{\\\"prompt\\\":\\\"Is this a product launch?\\\",\\\"triggerKeywords\\\":[\\\"launch\\\",\\\"new\\\"]}\",
    \"alertWebhookUrl\": \"\"
  }
]""",
}

# Run the Actor and wait for it to finish
run = client.actor("dubz/x-bulk-vision").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 '{
  "usernames": [
    "apify"
  ],
  "searchTerms": [
    "OpenAI",
    "Apify"
  ],
  "hashtags": [
    "webscraping",
    "automation"
  ],
  "visionPipelinesJson": "[\\n  {\\n    \\"name\\": \\"Gemini Product Detector\\",\\n    \\"provider\\": \\"gemini_vision\\",\\n    \\"enabled\\": false,\\n    \\"configJson\\": \\"{\\\\\\"prompt\\\\\\":\\\\\\"Is this a product launch?\\\\\\",\\\\\\"triggerKeywords\\\\\\":[\\\\\\"launch\\\\\\",\\\\\\"new\\\\\\"]}\\",\\n    \\"alertWebhookUrl\\": \\"\\"\\n  }\\n]"
}' |
apify call dubz/x-bulk-vision --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dubz/x-bulk-vision",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X (Twitter) Bulk Scraper/Monitor/Alerts + Vision",
        "description": "Monitor X (formerly Twitter) for specific content. Extract data, monitor, and optionally run image-based alerts using cloud vision APIs. Perfect for brand reputation management, tracking tweets, hashtags, specific images, and user activity.",
        "version": "0.0",
        "x-build-id": "RLw8KBgnUPmc9SuxP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dubz~x-bulk-vision/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dubz-x-bulk-vision",
                "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/dubz~x-bulk-vision/runs": {
            "post": {
                "operationId": "runs-sync-dubz-x-bulk-vision",
                "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/dubz~x-bulk-vision/run-sync": {
            "post": {
                "operationId": "run-sync-dubz-x-bulk-vision",
                "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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "X/Twitter Usernames",
                        "minItems": 1,
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of X/Twitter usernames to monitor (without @ symbol). Example: 'apify', 'elonmusk'",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search Terms (optional)",
                        "type": "array",
                        "description": "Filter tweets containing these keywords or phrases. Leave empty to collect all tweets.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "hashtags": {
                        "title": "Hashtags (optional)",
                        "type": "array",
                        "description": "Filter tweets containing these hashtags (with or without # symbol).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items to collect",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of tweets to collect across all usernames.",
                        "default": 100
                    },
                    "preferRss": {
                        "title": "Hyperdrive Mode",
                        "type": "boolean",
                        "description": "If enabled, use optimized hypderdrive scraping and only fall back to web scraping when needed (recommended).",
                        "default": true
                    },
                    "requireImages": {
                        "title": "Require images for items",
                        "type": "boolean",
                        "description": "If enabled, items without image URLs will be filtered out.",
                        "default": false
                    },
                    "rssTimeoutSecs": {
                        "title": "Hyperdrive timeout",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Timeout for Hyperdrive feed/post fetching (in seconds).",
                        "default": 10
                    },
                    "visionPipelinesJson": {
                        "title": "Vision Pipelines Configuration (Advanced)",
                        "type": "string",
                        "description": "Paste full JSON array of vision pipeline configurations. See README for examples. Leave empty to skip vision processing.",
                        "default": "[]"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
