# Nexus-IQ: Enterprise-Grade Competitive Intelligence (`rexreus/nexus-iq`) Actor

Extract competitive intelligence and sentiment analysis from 16 sources using AI-powered hierarchical summarization.

- **URL**: https://apify.com/rexreus/nexus-iq.md
- **Developed by:** [REXREUS D.O](https://apify.com/rexreus) (community)
- **Categories:** MCP servers, Agents, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$50.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 🚀 Nexus-IQ: Enterprise-Grade Competitive Intelligence Actor
<p>
<img src="https://i.imgur.com/B9auDN4.png" align="center">
</p>
**Nexus-IQ** is a high-performance, real-time competitive intelligence engine designed for GTM teams, Product Managers, and AI Agents. It orchestrates complex extraction, normalization, and AI-driven analysis across **16+ premium B2B platforms and communities** simultaneously.

Built natively with **Model Context Protocol (MCP)** support, Nexus-IQ empowers autonomous AI agents to research competitors with surgical precision while bypassing anti-bot measures and delivering token-optimized insights.

---

### 🌟 Key Capabilities

*   **🌐 16+ Premium Data Sources**: Unified access to G2, Capterra, Reddit, LinkedIn, Twitter/X, Glassdoor, and niche App Stores.
*   **🛡️ CloakBrowser™ Stealth**: Uses custom C++ source-level Chromium patches to bypass Cloudflare Turnstile, Datadome, Akamai, and CAPTCHA checks without runtime script leakage.
*   **🤖 Multi-LLM Intelligence**: Unified summaries and structured market signals via **Gemini, OpenAI, or Anthropic**.
*   **🔌 MCP Native**: Built-in support to run as an MCP Tool for Claude Desktop, Cursor, Claude Code, and other agentic environments.
*   **💰 Smart Proxy Guardrails**: Automated Residential Proxy budget enforcement and memory monitors to prevent runtime cost overrun.
*   **⚡ Direct Browser DOM Extraction**: Extracts the fully-rendered HTML/JSON directly from active browser pages, preventing WAF cookie-binding mismatches.
*   **🌍 Multi-lingual Summaries**: Delivers competitive reports in English, Indonesian, Spanish, German, or French.

---

### 📊 Supported Intelligence Sources

| **Tier 1 (Anti-Bot Heavy)** | **Tier 2 (Social & Community)** | **Tier 3 (App Stores & Niche)** |
| :--- | :--- | :--- |
| 🔹 G2 | 💬 Reddit | 📱 Google Play Store |
| 🔹 Capterra | 💬 Trustpilot | 📱 Apple App Store |
| 🔹 TrustRadius | 💬 Product Hunt | 🏢 Crunchbase |
| 🔹 Glassdoor | 💬 Hacker News | 🏢 PeerSpot |
| 🔹 LinkedIn Jobs | 💬 Twitter / X | 🏢 Software Advice |

---

### 🧠 Technical Architecture

```mermaid
graph TD
    User([User / AI Agent]) -->|Input Schema| Engine[Nexus-IQ Engine]
    Engine -->|1. Proxy Config| ProxyConfig[Apify Proxy Manager]
    ProxyConfig -->|Allocates| ResidentialProxy[Residential/Premium Proxies]
    Engine -->|2. Batch Dispatch| Batcher[Batcher Manager]
    
    Batcher -->|Tier 1 & 2: Stealth| CloakBrowser[CloakBrowser Chromium]
    CloakBrowser -->|Direct DOM Capture| HTMLOutput[Rendered HTML / JSON]
    
    Batcher -->|Tier 3: Standard| gotScraping[got-scraping client]
    gotScraping -->|Fetch check| PlaceholderHTML[Clean Fallback Data]
    
    HTMLOutput & PlaceholderHTML -->|Normalize| RawReviews[(Raw Reviews Datasets)]
    
    RawReviews -->|3. AI Tier| AIProvider[AI Provider Factory]
    AIProvider -->|Summarize Source| Summary[Source Summaries]
    Summary -->|Global Analysis| GlobalInsight[Global Insight Generator]
    
    GlobalInsight & RawReviews -->|4. Final Output| Output([Combined JSON Output])
````

***

### ⚙️ Configuration (Input Schema)

Configured via the standard Apify interface or JSON input:

| Parameter | Type | Description | Default |
| :--- | :--- | :--- | :--- |
| `target_company` \* | String | The competitor or brand name to research. | - |
| `sources` \* | Array | Select from 16 available intelligence providers. | `["G2", "Capterra", "Trustpilot"]` |
| `timeframe_days` | Integer | Data depth in days. | `7` |
| `target_language` | Enum | Output language (`english`, `indonesia`, `spanish`, `german`, `french`). | `english` |
| `ai_provider` | Enum | AI summarizer (`gemini`, `openai`, `anthropic`). | `gemini` |
| `ai_model` | String | Specific model identifier (e.g., `gemini-1.5-flash`, `gpt-4o-mini`). | `gemini-1.5-flash` |
| `proxyConfiguration` | Object | **Standard Apify Proxy Settings**. Residential/Premium proxies are recommended. | `{ "useApifyProxy": true }` |
| `max_proxy_cost_usd` | Float | Hard limit for proxy expenditure guardrail. | `5.0` |
| `skip_ai` | Boolean | Return raw reviews directly without AI summarization. | `false` |
| `force_refresh` | Boolean | Bypass cache and force fresh crawling. | `false` |

*\* Required fields*

***

### 🔌 Model Context Protocol (MCP) Integration

Because Nexus-IQ is hosted directly on the **Apify platform**, AI agents can interact with it serverless-ly. Below are the configurations to integrate this Actor into various popular AI clients:

#### 1. 💬 Claude Desktop

Add the configuration to your `claude_desktop_config.json` (typically located at `%APPDATA%\Claude\claude_desktop_config.json` on Windows or `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):

```json
{
  "mcpServers": {
    "nexus-iq": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "rexreus/Nexus-IQ"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_API_TOKEN"
      }
    }
  }
}
```

***

#### 2. 🎛️ Cursor

Cursor supports MCP servers directly through its graphical settings interface:

1. Go to **Settings (Gear Icon)** -> **Features** -> **MCP**.
2. Click **+ Add New MCP Server**.
3. Configure the server with these parameters:
   - **Name**: `nexus-iq`
   - **Type**: `command`
   - **Command**: `npx -y @apify/actors-mcp-server --tools rexreus/Nexus-IQ`
4. Under **Environment Variables**, add:
   - Key: `APIFY_TOKEN`
   - Value: `YOUR_APIFY_API_TOKEN`
5. Click **Save**.

***

#### 3. 🌊 Windsurf

Add the configuration to your Windsurf global `mcp_config.json` (typically located at `~/.codeium/windsurf/mcp_config.json`):

```json
{
  "mcpServers": {
    "nexus-iq": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "rexreus/Nexus-IQ"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_API_TOKEN"
      }
    }
  }
}
```

***

#### 4. 🤖 Cline (VS Code Extension) / Hermes

Cline uses a dedicated configuration file named `cline_mcp_settings.json` (typically located in `%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json` on Windows):

```json
{
  "mcpServers": {
    "nexus-iq": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "rexreus/Nexus-IQ"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_API_TOKEN"
      },
      "disabled": false
    }
  }
}
```

***

#### 5. 💻 Claude Code (CLI)

You can add the tool to Claude Code by running this command in your terminal:

```bash
claude mcp add nexus-iq npx -y @apify/actors-mcp-server --tools rexreus/Nexus-IQ
```

*Make sure the `APIFY_TOKEN` environment variable is exported in your shell session (`export APIFY_TOKEN=...`) so that Claude Code inherits it.*

***

### 🛠️ Exposed MCP Tools (Skills)

Once the server is configured, the following tool (or "skill") is exposed to your AI agent:

#### ⚙️ `nexus_iq_get_sentiment`

**Description**: Triggers the Apify Actor to gather competitive intelligence and execute sentiment analysis on the target company.

##### Tool Parameters:

| Parameter | Type | Required | Description | Default |
| :--- | :--- | :--- | :--- | :--- |
| `target_company` | string | **Yes** | The competitor/brand name to research. | - |
| `sources` | array | **Yes** | Array of target platforms to scrape. Choose from: `G2`, `Capterra`, `TrustRadius`, `Reddit`, `Glassdoor`, `Trustpilot`, `Product Hunt`, `Hacker News`, `LinkedIn Jobs`, `Twitter/X`, `GetApp`, `Software Advice`, `PeerSpot`, `Crunchbase`, `Google Play`, `Apple App Store`. | - |
| `timeframe_days` | integer | No | Number of days in the past to pull reviews. | `7` |
| `target_language` | string | No | Output language for AI insights. | `"english"` |
| `ai_provider` | string | No | Preferred AI provider (`gemini`, `openai`, `anthropic`). | `"gemini"` |
| `ai_model` | string | No | Specific model identifier (e.g. `gemini-1.5-flash`). | - |
| `skip_ai` | boolean | No | Return raw JSON data without AI summarization. | `false` |

***

### 🤖 Example Agent Tasks (How to Prompt your AI Agent)

Once the MCP integration is complete, you can give your AI agent complex commands directly. Here are sample prompts you can copy and use:

> \[!TIP]
> **Task 1: Competitor Feature & Sentiment Gap**
> *"Use the Nexus-IQ tool to research G2, Reddit, and Twitter reviews for competitor 'Apify' over the last 14 days. Summarize the results in Indonesian, focusing on the top complaints and feature requests."*

> \[!TIP]
> **Task 2: Churn & Pricing Signal Check**
> *"Identify if there are any churn risks or pricing concerns for 'Salesforce' by running a Nexus-IQ query on G2 and Capterra. Compare what you find with HubSpot."*

> \[!TIP]
> **Task 3: App Store Sentiment Audit**
> *"Audit user reviews for 'Slack' on Google Play and Apple App Store using Nexus-IQ. Extract the raw reviews and compile a summary of competitor mentions in German."*

***

### 📦 Output Schema

Nexus-IQ returns a structured JSON output that contains metadata, clean review text datasets, and standard market intelligence schemas:

```json
{
  "query_metadata": {
    "target_company": "Apify",
    "timeframe_days": 7,
    "sources_requested": ["G2", "Google Play"],
    "sources_successful": ["G2", "Google Play"],
    "total_reviews": 32,
    "timestamp": "2026-06-05T08:00:00.000Z",
    "latency_ms": 28400,
    "ai_provider": "gemini",
    "ai_model": "gemini-1.5-flash"
  },
  "global_insight": {
    "summary": "Users praise the extensive developer capabilities and proxy integration, but cite complex javascript selector setup as a major learning curve.",
    "sentiment": {
      "average_rating": 4.5,
      "total_reviews": 32,
      "sentiment_score": 0.85,
      "top_praises": ["stealth capabilities", "developer experience", "integrations"],
      "top_complaints": ["learning curve", "datacenter IP blocking"]
    },
    "signals": {
      "churn_risk": false,
      "feature_requests": ["No-code selector builder"],
      "pricing_mentions": ["granularity of computation tiers"],
      "competitor_mentions": ["BrightData", "ZenRows"]
    }
  },
  "raw_reviews": [
    {
      "id": "a9f8b7c6...",
      "source": "G2",
      "author": "Steve D.",
      "rating": 5,
      "title": "Standard for web scaling",
      "text": "Apify actors make it easy to scale web extraction tasks safely.",
      "date": "2026-06-03T12:00:00.000Z",
      "url": "https://www.g2.com/products/apify/reviews"
    }
  ]
}
```

***

### 🔒 Security & Privacy

- **BYOK (Bring Your Own Key)**: Provider API keys are handled as secrets and are never stored on Apify's datasets or printed in the log.
- **PII Masking**: Automatic scrubbing of sensitive client data (e.g. user emails, phone numbers) before passing it to AI analysis.
- **Challenge Isolation**: If a source is blocked by an unresolvable anti-bot challenge, it is cleanly reported under `failed_sources` rather than returning mock/corrupted data.

***

*Developed by the Nexus-IQ Engineering Team. Optimized for Autonomous AI.*

# Actor input Schema

## `target_company` (type: `string`):

Company name to research

## `sources` (type: `array`):

Platforms to extract reviews from

## `timeframe_days` (type: `integer`):

Number of days in the past to collect reviews (e.g. 7)

## `target_language` (type: `string`):

Language to use for AI output/summaries.

## `ai_provider` (type: `string`):

Preferred AI provider used for analysis.

## `ai_model` (type: `string`):

Specific model ID

## `gemini_api_key` (type: `string`):

(Optional) API key for Gemini provider; required if `ai_provider` is `gemini`.

## `openai_api_key` (type: `string`):

(Optional) API key for OpenAI; required if `ai_provider` is `openai`.

## `anthropic_api_key` (type: `string`):

(Optional) API key for Anthropic; required if `ai_provider` is `anthropic`.

## `skip_ai` (type: `boolean`):

When true, the pipeline returns raw extractions without AI summarization or analysis.

## `force_refresh` (type: `boolean`):

Bypass cached results and force fresh extraction from sources.

## `max_proxy_cost_usd` (type: `number`):

Maximum allowed proxy expenditure in USD for a single run (guardrail).

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

Select proxies to be used by the crawler. Datacenter proxies may get blocked by anti-scraping tools. Residential proxies are recommended.

## Actor input object example

```json
{
  "target_company": "Apify",
  "sources": [
    "G2",
    "Capterra",
    "Trustpilot"
  ],
  "timeframe_days": 7,
  "target_language": "english",
  "ai_provider": "gemini",
  "ai_model": "gemma-4-26b-a4b-it",
  "skip_ai": false,
  "force_refresh": false,
  "max_proxy_cost_usd": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing competitive intelligence and sentiment analysis results.

# 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 = {
    "target_company": "Apify",
    "sources": [
        "G2",
        "Capterra",
        "Trustpilot"
    ],
    "timeframe_days": 7,
    "target_language": "english",
    "ai_provider": "gemini",
    "ai_model": "gemma-4-26b-a4b-it",
    "skip_ai": false,
    "force_refresh": false,
    "max_proxy_cost_usd": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rexreus/nexus-iq").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 = {
    "target_company": "Apify",
    "sources": [
        "G2",
        "Capterra",
        "Trustpilot",
    ],
    "timeframe_days": 7,
    "target_language": "english",
    "ai_provider": "gemini",
    "ai_model": "gemma-4-26b-a4b-it",
    "skip_ai": False,
    "force_refresh": False,
    "max_proxy_cost_usd": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rexreus/nexus-iq").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 '{
  "target_company": "Apify",
  "sources": [
    "G2",
    "Capterra",
    "Trustpilot"
  ],
  "timeframe_days": 7,
  "target_language": "english",
  "ai_provider": "gemini",
  "ai_model": "gemma-4-26b-a4b-it",
  "skip_ai": false,
  "force_refresh": false,
  "max_proxy_cost_usd": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rexreus/nexus-iq --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nexus-IQ: Enterprise-Grade Competitive Intelligence",
        "description": "Extract competitive intelligence and sentiment analysis from 16 sources using AI-powered hierarchical summarization.",
        "version": "0.0",
        "x-build-id": "E7vUj5IeIQYflZXhc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rexreus~nexus-iq/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rexreus-nexus-iq",
                "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/rexreus~nexus-iq/runs": {
            "post": {
                "operationId": "runs-sync-rexreus-nexus-iq",
                "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/rexreus~nexus-iq/run-sync": {
            "post": {
                "operationId": "run-sync-rexreus-nexus-iq",
                "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": [
                    "target_company",
                    "sources"
                ],
                "properties": {
                    "target_company": {
                        "title": "Target Company",
                        "type": "string",
                        "description": "Company name to research"
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Platforms to extract reviews from",
                        "items": {
                            "type": "string",
                            "enum": [
                                "G2",
                                "Capterra",
                                "TrustRadius",
                                "Reddit",
                                "Glassdoor",
                                "Trustpilot",
                                "Product Hunt",
                                "Hacker News",
                                "LinkedIn Jobs",
                                "Twitter/X",
                                "GetApp",
                                "Software Advice",
                                "PeerSpot",
                                "Crunchbase",
                                "Google Play",
                                "Apple App Store"
                            ]
                        }
                    },
                    "timeframe_days": {
                        "title": "Timeframe (Days)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of days in the past to collect reviews (e.g. 7)",
                        "default": 7
                    },
                    "target_language": {
                        "title": "Target Language",
                        "enum": [
                            "english",
                            "indonesia",
                            "spanish",
                            "german",
                            "french"
                        ],
                        "type": "string",
                        "description": "Language to use for AI output/summaries.",
                        "default": "english"
                    },
                    "ai_provider": {
                        "title": "AI Provider",
                        "enum": [
                            "gemini",
                            "openai",
                            "anthropic"
                        ],
                        "type": "string",
                        "description": "Preferred AI provider used for analysis.",
                        "default": "gemini"
                    },
                    "ai_model": {
                        "title": "AI Model",
                        "type": "string",
                        "description": "Specific model ID"
                    },
                    "gemini_api_key": {
                        "title": "Gemini API Key",
                        "type": "string",
                        "description": "(Optional) API key for Gemini provider; required if `ai_provider` is `gemini`."
                    },
                    "openai_api_key": {
                        "title": "OpenAI API Key",
                        "type": "string",
                        "description": "(Optional) API key for OpenAI; required if `ai_provider` is `openai`."
                    },
                    "anthropic_api_key": {
                        "title": "Anthropic API Key",
                        "type": "string",
                        "description": "(Optional) API key for Anthropic; required if `ai_provider` is `anthropic`."
                    },
                    "skip_ai": {
                        "title": "Skip AI Processing",
                        "type": "boolean",
                        "description": "When true, the pipeline returns raw extractions without AI summarization or analysis.",
                        "default": false
                    },
                    "force_refresh": {
                        "title": "Force Refresh Cache",
                        "type": "boolean",
                        "description": "Bypass cached results and force fresh extraction from sources.",
                        "default": false
                    },
                    "max_proxy_cost_usd": {
                        "title": "Max Proxy Cost (USD)",
                        "type": "number",
                        "description": "Maximum allowed proxy expenditure in USD for a single run (guardrail).",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to be used by the crawler. Datacenter proxies may get blocked by anti-scraping tools. Residential proxies are recommended.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```