# AI Tools Directory Scraper (`automation-lab/ai-tools-directory-scraper`) Actor

Scrape AI tool directories (Futurepedia, Toolify.ai) for competitive intelligence. Extract tool name, description, category, pricing model, URL, rating, features, and launch date.

- **URL**: https://apify.com/automation-lab/ai-tools-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** SEO tools
- **Stats:** 1 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

## AI Tools Directory Scraper

Extract structured data from the world's largest AI tools directories — **Futurepedia** and **Toolify.ai**. Get tool names, descriptions, pricing models, categories, ratings, feature lists, pros/cons, and social links in a clean, spreadsheet-ready format for competitive intelligence and market research.

### What does the AI Tools Directory Scraper do?

The **AI Tools Directory Scraper** crawls [Futurepedia.io](https://www.futurepedia.io) and [Toolify.ai](https://www.toolify.ai) — two of the largest directories of AI-powered tools — and extracts structured data from every listing.

For each AI tool you can extract:
- 📝 Name, description, and full long-form description
- 🏷️ Category and all associated tags
- 💰 Pricing model (free, freemium, paid)
- ⭐ User ratings and review counts
- 🌐 Tool website URL
- 🔗 Directory listing URL
- 📋 Key features list, pros, and cons (with detail mode)
- 🔗 Social media links (Twitter, LinkedIn, GitHub, YouTube, Discord)
- 📅 Launch/added date

Browse by category (e.g., chatbots, image generators, code assistants), run a keyword search, or filter by pricing model. No API key or login required.

### Who is the AI Tools Directory Scraper for?

**🏢 Product managers and startup founders**
Conducting competitive landscape analysis. Monitor which AI tools compete in your space, track their pricing changes, and identify whitespace opportunities by analyzing feature gaps across hundreds of competitors at once.

**📊 VC analysts and investors**
Building deal flow databases and market maps. Quickly export the full landscape of AI tools in any vertical — chatbots, image generation, sales automation — to spot trends and emerging players before they appear in press coverage.

**🤖 AI newsletter writers and curators**
Publishing roundups of the latest AI tools. Automate your "Top 10 AI tools for X" content by scraping fresh tool listings weekly, filtered by category and sorted by rating.

**📈 Marketers and growth teams**
Tracking competitor launches, pricing movements, and feature rollouts. Set up scheduled runs to get weekly snapshots of a category and detect changes over time.

**🔬 Researchers and analysts**
Building datasets for academic or commercial research on AI tool adoption, pricing trends, and market saturation across categories.

### Why use this scraper?

- ✅ **No API key needed** — Futurepedia and Toolify don't have public APIs; this scraper does the work
- ✅ **Cloudflare-bypassing Playwright** — both sites use Cloudflare protection; our actor handles it reliably
- ✅ **Structured, flat output** — every field is a primitive value, ready for Google Sheets or Excel export
- ✅ **Category + search + pricing filters** — target exactly the tools you care about
- ✅ **Detail enrichment mode** — optionally visit each tool page for features, pros/cons, and social links
- ✅ **Pagination handled automatically** — scrapes beyond the first page to reach your target count
- ✅ **Deduplicated results** — no duplicate tools even when running across multiple categories

### What data can you extract from AI tools directories?

| Field | Description | Example |
|-------|-------------|---------|
| `name` | Tool display name | "ChatGPT" |
| `source` | Directory source | "futurepedia" |
| `description` | Short description | "Research, create, and automate tasks..." |
| `fullDescription` | Long description (detail mode) | Full paragraph about the tool |
| `category` | Primary category | "Ai Chatbots" |
| `categories` | All tags/categories | ["Ai Chatbots", "Research", "Ai Agents"] |
| `pricingModel` | Pricing type | "freemium" / "free" / "paid" / "unknown" |
| `pricingDetails` | Raw pricing text | "Freemium" / "Contact for Pricing" |
| `url` | Tool website URL | "https://chatgpt.com/" |
| `directoryUrl` | Listing page URL | "https://www.futurepedia.io/tool/chatgpt" |
| `rating` | Average user rating (0-5) | 4.3 |
| `reviewCount` | Number of ratings | 9 |
| `monthlyVisitors` | Monthly visits (Toolify) | 6303 |
| `features` | Key features list (detail mode) | ["GPT-5 Integration: ...", "Agent Mode: ..."] |
| `pros` | Pros list (detail mode) | ["Enhanced intelligence: ...", ...] |
| `cons` | Cons list (detail mode) | ["Occasional inaccuracies", ...] |
| `logoUrl` | Tool logo image URL | CDN URL |
| `launchDate` | Date added to directory | "2024-01-15" |
| `socialLinks` | Social media URLs (detail mode) | {twitter, linkedin, github, ...} |
| `isVerified` | Verified badge | true / false |
| `isFeatured` | Featured/Editor's Pick status | true / false |
| `scrapedAt` | Extraction timestamp | "2026-04-05T10:30:00Z" |

### How much does it cost to scrape AI tool directories?

This actor uses **Pay-Per-Event (PPE) pricing** — you pay per tool scraped, not per compute minute.

| Volume | Cost |
|--------|------|
| 1–100 tools | $0.003/tool (max $0.30) |
| 100–1,000 tools | $0.0027/tool |
| 1,000–5,000 tools | $0.0024/tool |
| 5,000+ tools (Enterprise) | $0.0012/tool |

**Plus a one-time $0.03 start fee per run.**

**Real-world cost examples:**
- Scrape 100 chatbot tools (listing mode): ~$0.33
- Scrape 100 chatbot tools (detail mode, with features/pros/cons): ~$0.33 + extra Playwright time
- Export all image generation tools (~200): ~$0.63
- Full Futurepedia chatbots category (~200 tools): ~$0.63

**Free plan estimate:** Apify's free plan includes $5 in monthly credits. At $0.003/tool, you can scrape ~1,600 AI tools per month on the free plan (listing mode).

### How to scrape AI tools from Futurepedia

1. Go to the [AI Tools Directory Scraper](https://apify.com/automation-lab/ai-tools-directory-scraper) page on Apify Store
2. Click **Try for free**
3. In **Source directory**, select "Futurepedia.io" (default)
4. Optionally set a **Category filter** (e.g., "chatbots", "image-generators")
5. Set **Max tools to scrape** (start with 20 for a test run)
6. Toggle **Scrape detail pages** on to get features, pros/cons, and social links (slower but richer)
7. Click **Save & Run**
8. When the run completes, download results as JSON, CSV, or Excel

**Example inputs for different use cases:**

```json
// Scrape chatbot category (fast listing mode)
{
  "source": "futurepedia",
  "category": "chatbots",
  "maxTools": 100,
  "includeDetails": false
}
````

```json
// Keyword search with detail enrichment
{
  "source": "futurepedia",
  "searchQuery": "customer support automation",
  "maxTools": 50,
  "includeDetails": true
}
```

```json
// Free tools only from image generation
{
  "source": "futurepedia",
  "category": "image-generators",
  "maxTools": 200,
  "pricingFilter": "free",
  "includeDetails": false
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `source` | Select | "futurepedia" | Source directory to scrape. Options: "futurepedia", "toolify", "all" |
| `category` | String | — | Filter by category slug (e.g., "chatbots", "image-generators", "code-assistant") |
| `searchQuery` | String | — | Keyword search for tools by name or description |
| `maxTools` | Integer | 100 | Maximum number of tools to extract |
| `includeDetails` | Boolean | true | Visit each tool's detail page for features, pros/cons, and social links |
| `pricingFilter` | Select | "all" | Filter by pricing model: "all", "free", "freemium", "paid" |
| `proxyConfiguration` | Object | Residential US | Proxy configuration. Residential proxies recommended for Cloudflare bypass |

**Futurepedia category slugs** (use in `category` field):

- `chatbots` — AI chatbots and virtual assistants
- `image-generators` — AI image creation tools
- `text-generators` — AI writing assistants
- `code-assistant` — AI coding tools
- `video` — AI video generation and editing
- `productivity` — Productivity and workflow tools
- `research-assistant` — Research and analysis tools
- `ai-agents` — Autonomous AI agent platforms

### Output examples

**Listing mode output (fast, no detail pages):**

```json
{
  "name": "ChatGPT",
  "source": "futurepedia",
  "description": "Research, create, and automate tasks with the leader in AI.",
  "category": "Ai Chatbots",
  "categories": ["Ai Chatbots", "Research", "Ai Agents"],
  "pricingModel": "freemium",
  "pricingDetails": "Freemium",
  "url": "https://chatgpt.com/",
  "directoryUrl": "https://www.futurepedia.io/tool/chatgpt",
  "rating": 4.3,
  "reviewCount": 9,
  "logoUrl": "https://cdn2.futurepedia.io/...",
  "launchDate": null,
  "isVerified": false,
  "isFeatured": true,
  "scrapedAt": "2026-04-05T10:30:00.000Z"
}
```

**Detail mode output (includes features, pros/cons, social links):**

```json
{
  "name": "ChatGPT",
  "source": "futurepedia",
  "description": "Research, create, and automate tasks with the leader in AI.",
  "fullDescription": "ChatGPT is a conversational AI platform that combines advanced language capabilities...",
  "category": "Ai Chatbots",
  "categories": ["Ai Chatbots", "Research", "Ai Agents"],
  "pricingModel": "freemium",
  "url": "https://chatgpt.com/",
  "directoryUrl": "https://www.futurepedia.io/tool/chatgpt",
  "rating": 4.3,
  "reviewCount": 9,
  "features": [
    "GPT-5 Integration: Deeper reasoning capabilities and improved performance...",
    "Agent Mode: Executes multi-step tasks in a virtual environment...",
    "Deep Research: Conducts autonomous online investigations..."
  ],
  "pros": [
    "Enhanced intelligence: GPT-5 improves reasoning and adaptability.",
    "Extensive functionality: Combines conversational AI with research and automation."
  ],
  "cons": [
    "Occasional inaccuracies: Output may still require fact-checking.",
    "Usage limits: Higher-tier tools are capped by subscription plan."
  ],
  "socialLinks": {
    "twitter": "https://x.com/OpenAI",
    "linkedin": "https://www.linkedin.com/company/openai",
    "github": "https://github.com/openai",
    "youtube": "https://www.youtube.com/OpenAI",
    "discord": "https://discord.gg/openai"
  },
  "isVerified": false,
  "isFeatured": true,
  "scrapedAt": "2026-04-05T10:30:00.000Z"
}
```

### Tips for best results

- 🚀 **Start small**: Run with `maxTools: 20` first to verify the output format before scaling up
- ⚡ **Use listing mode for large exports**: `includeDetails: false` is 3–5x faster and sufficient for competitive overviews
- 💰 **Use detail mode for depth**: Enable `includeDetails: true` when you need features, pros/cons, and social links for a smaller set of tools
- 🏷️ **Filter by pricing**: Set `pricingFilter: "freemium"` to find tools with free tiers you can test, or `"paid"` for premium-only tools
- 📅 **Schedule weekly runs**: Set up a scheduled run to track new tools added to a category each week
- 🔍 **Combine category + pricing**: Use both filters for precise targeting (e.g., free image generators)
- 📊 **Export to Google Sheets**: Use Apify's built-in Google Sheets integration for live-updating spreadsheets

### Integrations

**🗂️ AI Tools Directory Scraper → Google Sheets**
Run weekly on a category to maintain a live competitive landscape spreadsheet. New tools automatically appear in Sheets via the Apify + Google Sheets integration.

**📬 AI Tools Directory Scraper → Slack/Discord**
Use an Apify webhook + Zapier/Make to post notifications when new high-rated tools (rating > 4.5) appear in your target category. Stay ahead of competitors.

**📊 AI Tools Directory Scraper → Airtable**
Build a CRM for AI tools you're evaluating. Export structured tool data to Airtable, then track your testing notes and integration status alongside the original data.

**🔄 Scheduled monitoring**
Run daily/weekly with `pricingFilter: "freemium"` to detect when tools shift from free to paid — a common signal that they're scaling revenue.

**🤖 AI Tools Directory Scraper → Claude/GPT analysis**
Export a category to CSV, then feed it to an AI assistant with a prompt like "Analyze this dataset of AI writing tools and identify the top 3 underserved niches based on feature gaps." Great for strategic planning.

### Using the Apify API

You can trigger this actor programmatically 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/ai-tools-directory-scraper').call({
  source: 'futurepedia',
  category: 'chatbots',
  maxTools: 100,
  includeDetails: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} AI tools`);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/ai-tools-directory-scraper").call(run_input={
    "source": "futurepedia",
    "category": "image-generators",
    "maxTools": 200,
    "includeDetails": False,
    "pricingFilter": "freemium",
})

dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"Found {len(dataset_items)} AI tools")
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ai-tools-directory-scraper/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{
    "source": "futurepedia",
    "category": "code-assistant",
    "maxTools": 50,
    "includeDetails": true
  }'
```

### Use with AI agents via MCP

AI Tools Directory 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/ai-tools-directory-scraper to get all freemium chatbot tools from Futurepedia with ratings above 4 stars"
- "Scrape the top 50 AI image generation tools from Futurepedia with their features and pros/cons, then summarize the most common pricing models"
- "Get 200 AI productivity tools and export as CSV — I want to find tools with free tiers that compete with Notion AI"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape AI tools directories?

This actor collects **publicly available information** from Futurepedia.io and Toolify.ai — the same data any visitor can see in their browser. No authentication is required or bypassed. Futurepedia and Toolify display this data publicly to drive tool discovery.

Web scraping of publicly available data is generally considered legal in most jurisdictions, as confirmed by the *hiQ Labs v. LinkedIn* (9th Circuit) ruling and similar EU case law. Apify operates under [ethical scraping principles](https://apify.com/legal/ethical-scraping).

**Best practices we recommend:**

- Use scraped data for research, analysis, and product development — not for republishing without attribution
- Respect each tool's own website terms when visiting their URLs
- Don't use this data to spam or cold-contact tool developers

### FAQ

**How fast does the scraper work?**
In listing mode (no detail pages), the actor scrapes approximately 12–24 tools per page visit. With Playwright and residential proxies, each page takes 4–8 seconds. You can expect ~100 tools in under 2 minutes in listing mode.

With `includeDetails: true`, each tool requires an additional page visit (~5–10 seconds), so 100 tools takes roughly 15–25 minutes. For large runs, use listing mode first to identify tools of interest, then re-scrape specific tools with detail mode.

**How much does it cost to scrape 1,000 AI tools?**
At $0.003/tool for the first 100 and $0.0027/tool for the next 900, plus a $0.03 start fee: approximately **$2.73** for 1,000 tools in listing mode.

**Why do some tools show `pricingModel: "unknown"`?**
Some tools list custom pricing like "Contact for Pricing" or "Free Trial". These don't fit the free/freemium/paid model cleanly, so they're classified as "unknown". The raw `pricingDetails` field always contains the original text from the directory.

**Why are results empty or fewer than expected?**

- Check that your `category` slug matches a real Futurepedia category (e.g., `chatbots`, not `Chatbots`)
- Some category pages load slowly — try increasing the actor timeout
- If using `pricingFilter`, the category may have fewer tools matching that filter than `maxTools`

**Does it work for Toolify.ai?**
Yes, Toolify is supported with source `"toolify"` or `"all"`. Toolify uses Cloudflare protection similar to Futurepedia. Toolify provides monthly visitor data (`monthlyVisitors`) that Futurepedia doesn't offer. Note: Toolify's DOM structure is more dynamic and may occasionally require proxy rotation.

**Can I scrape both directories at once?**
Yes — set `source: "all"` to scrape both Futurepedia and Toolify in a single run. The `source` field in each output record identifies which directory it came from. Set `maxTools` to the combined total you want.

### Related scrapers

Looking for more data extraction tools? Check out these other automation-lab actors:

- 🔍 [Bing Search Scraper](https://apify.com/automation-lab/bing-search-scraper) — Scrape Bing search results for SERP analysis
- 📋 [Product Hunt Scraper](https://apify.com/automation-lab/product-hunt-scraper) — Extract product launches and upvotes from Product Hunt
- 🛍️ [AppSumo Scraper](https://apify.com/automation-lab/appsumo-scraper) — Scrape lifetime software deals and reviews
- 📊 [Apify Store Analyzer](https://apify.com/automation-lab/apify-store-analyzer) — Analyze actors and pricing in the Apify Store
- 🏪 [Amazon Product Scraper](https://apify.com/automation-lab/amazon-scraper) — Extract Amazon product listings and reviews

# Actor input Schema

## `source` (type: `string`):

Select which AI tools directory to scrape. Choose 'all' to scrape both Futurepedia and Toolify.ai in a single run.

## `category` (type: `string`):

Filter tools by category (e.g. 'image-generation', 'chatbot', 'productivity'). Leave empty to scrape all categories. For Futurepedia use the category slug from the URL. For Toolify use the category name.

## `searchQuery` (type: `string`):

Search for specific AI tools by keyword. Works as a name/description filter. Leave empty to browse all tools.

## `maxTools` (type: `integer`):

Maximum number of AI tools to extract. Keep low for initial tests. Increase for full directory exports.

## `includeDetails` (type: `boolean`):

Visit each tool's detail page to extract additional fields: full description, features list, pros/cons, social links, and sub-ratings. Slower but more complete data. Disable for fast listing-only mode.

## `pricingFilter` (type: `string`):

Filter by pricing model. Select 'all' to include all tools regardless of price.

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

Configure proxy settings. Residential proxies are recommended for bypassing Cloudflare protection on these sites.

## Actor input object example

```json
{
  "source": "futurepedia",
  "category": "",
  "searchQuery": "",
  "maxTools": 20,
  "includeDetails": true,
  "pricingFilter": "all"
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "source": "futurepedia",
    "maxTools": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ai-tools-directory-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "source": "futurepedia",
    "maxTools": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ai-tools-directory-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 '{
  "source": "futurepedia",
  "maxTools": 20
}' |
apify call automation-lab/ai-tools-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Tools Directory Scraper",
        "description": "Scrape AI tool directories (Futurepedia, Toolify.ai) for competitive intelligence. Extract tool name, description, category, pricing model, URL, rating, features, and launch date.",
        "version": "0.1",
        "x-build-id": "jmGgCm3RA7N23VGcm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ai-tools-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ai-tools-directory-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~ai-tools-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ai-tools-directory-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~ai-tools-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ai-tools-directory-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": [
                    "source",
                    "maxTools"
                ],
                "properties": {
                    "source": {
                        "title": "📂 Source directory",
                        "enum": [
                            "futurepedia",
                            "toolify",
                            "all"
                        ],
                        "type": "string",
                        "description": "Select which AI tools directory to scrape. Choose 'all' to scrape both Futurepedia and Toolify.ai in a single run.",
                        "default": "futurepedia"
                    },
                    "category": {
                        "title": "🏷️ Category filter",
                        "type": "string",
                        "description": "Filter tools by category (e.g. 'image-generation', 'chatbot', 'productivity'). Leave empty to scrape all categories. For Futurepedia use the category slug from the URL. For Toolify use the category name.",
                        "default": ""
                    },
                    "searchQuery": {
                        "title": "🔍 Search query",
                        "type": "string",
                        "description": "Search for specific AI tools by keyword. Works as a name/description filter. Leave empty to browse all tools.",
                        "default": ""
                    },
                    "maxTools": {
                        "title": "📊 Max tools to scrape",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of AI tools to extract. Keep low for initial tests. Increase for full directory exports.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "📋 Scrape detail pages",
                        "type": "boolean",
                        "description": "Visit each tool's detail page to extract additional fields: full description, features list, pros/cons, social links, and sub-ratings. Slower but more complete data. Disable for fast listing-only mode.",
                        "default": true
                    },
                    "pricingFilter": {
                        "title": "💰 Pricing model filter",
                        "enum": [
                            "all",
                            "free",
                            "freemium",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Filter by pricing model. Select 'all' to include all tools regardless of price.",
                        "default": "all"
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Configure proxy settings. Residential proxies are recommended for bypassing Cloudflare protection on these sites."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
