# $0.9/1k Toolify AI Tools Scraper (`architjn/toolify-scraper`) Actor

Scrape AI tool and website listings from Toolify.ai — new, most saved, most used, apps, and keyword search. Export names, URLs, categories, traffic, and collection stats.

- **URL**: https://apify.com/architjn/toolify-scraper.md
- **Developed by:** [Archit Jain](https://apify.com/architjn) (community)
- **Categories:** AI, Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 25 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Toolify AI Tools Scraper

Collect AI tool and website listings from [Toolify.ai](https://www.toolify.ai)—the directory of AI apps, websites, and tools. Each row includes the tool name, website URL, Toolify profile link, categories, traffic stats, and whether the listing is free or sponsored.

You do **not** need a Toolify account. The actor reads public list API results only.

### Input

Configure these fields in the Apify Console **Input** tab before you click **Start**.

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| **List modes** | multi-select | Yes | New | Pick one or more lists: **New**, **Most saved**, **Most used**, or **Apps**. Each mode is scraped separately. |
| **Search keyword** | text | No | *(empty)* | Optional. Runs an extra keyword search pass and filters the **Apps** list. Does **not** filter New, Most saved, or Most used rankings. |
| **Max items per list mode** | number | Yes | `50` | How many tools to save **for each** list mode (and for the keyword search pass when a keyword is set). Maximum is **500**. |
| **Proxy configuration** | proxy | No | Residential on Apify | Apify residential proxy (on by default on Apify cloud). |

#### List mode options

- **New** — recently added tools
- **Most saved** — tools users save most often
- **Most used** — tools with highest usage
- **Apps** — app listings (ordered by date added)

When you set a **Search keyword**, the actor also runs a site-wide keyword search (separate from the ranking lists).

### Output

Results appear in the run **Dataset** tab—one row per tool per list mode (the same tool can appear in multiple modes).

| Field | What you get |
|-------|----------------|
| `listMode` | Which list this row came from (`new`, `most_saved`, `most_used`, `apps`, `search`) |
| `rank` | Position in that list (1 = first) |
| `keyword` | Your search keyword, if this row is from Apps (with keyword) or Search |
| `totalInList` | Total tools reported by Toolify for that list |
| `toolId`, `name`, `handle` | Tool identifiers |
| `toolifyUrl` | Link to the tool on Toolify.ai |
| `website`, `websiteName` | External product URL and display name |
| `description`, `summary` | Short descriptions from the listing |
| `imageUrl`, `logoUrl` | Cover image and logo URLs |
| `collectedCount`, `monthVisitedCount` | Save count and monthly visit estimate |
| `isFree`, `isAd` | Whether the tool is marked free or sponsored |
| `categoryNames`, `categoryHandles` | Comma-separated Toolify categories |
| `trafficTopRegion`, `trafficTopRegionValue` | Top traffic region and share, when available |
| `scrapedAt` | When this row was collected |

Download as **JSON**, **CSV**, or **Excel** from the dataset, or use the Apify API and integrations.

### Pricing Structure

**Pay per usage** — you are charged for compute units (CPU, memory, runtime) consumed during the run. If the actor falls back to a browser session to pass Cloudflare, runs may use more resources than a plain API call. Set a **spending limit** on the run before you start if you are testing.

### Examples

#### Example 1: Latest tools

**Input:**

```json
{
  "listModes": ["new"],
  "keyword": "",
  "maxItemsPerMode": 25
}
```

**Output:** Up to 25 rows from the New list.

#### Example 2: Compare rankings

**Input:**

```json
{
  "listModes": ["new", "most_used"],
  "maxItemsPerMode": 50
}
```

**Output:** Up to 50 rows per mode (up to 100 total). The same tool may appear twice with different `listMode` and `rank`.

#### Example 3: Search “video” and apps

**Input:**

```json
{
  "listModes": ["apps"],
  "keyword": "video",
  "maxItemsPerMode": 30
}
```

**Output:** Up to 30 apps matching “video”, plus up to 30 rows from the keyword search pass.

### Best Practices

1. **Start small** — use `maxItemsPerMode` of 10–25 while testing; each mode adds more rows and runtime.
2. **Keyword scope** — keywords filter Apps and the search pass only; use **Search** output (`listMode: search`) for keyword discovery, not ranking lists.
3. **Multi-mode runs** — selecting four modes with `maxItemsPerMode: 500` can produce up to 2,000 rows; watch dataset size and cost.
4. **Sponsored listings** — `isAd: true` rows are included by default; filter them in your export if you want organic-only lists.
5. **Cloudflare** — Toolify may block plain API requests; the actor automatically retries with a headless browser when needed (uses proxy when configured).
6. **Residential proxy** — leave proxy enabled on Apify cloud if you see empty results or blocks.

### Limitations

- List-only data (no full Toolify profile page scrape).
- Keyword search totals on Toolify may cap below your `maxItemsPerMode` for broad terms.
- Ranking lists (New, Most saved, Most used) ignore the keyword filter by design.

# Actor input Schema

## `listModes` (type: `array`):

One or more Toolify directory lists to scrape. Each selected mode is scraped separately up to max items per mode.

## `keyword` (type: `string`):

Optional. Runs an extra keyword search pass and filters the Apps list. Does not filter New, Most saved, or Most used rankings.

## `maxItemsPerMode` (type: `integer`):

Maximum tools to save for each list mode (and for the keyword search pass when a keyword is set). Hard cap is 500.

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

Apify residential proxy on cloud (enabled by default). For local runs, use a .env file with APIFY_TOKEN or proxy credentials, or enable Apify proxy in this field.

## Actor input object example

```json
{
  "listModes": [
    "new"
  ],
  "keyword": "",
  "maxItemsPerMode": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `tools` (type: `string`):

Scraped tools with list mode, rank, URLs, categories, and traffic stats.

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

All tool records from this run in JSON format.

## `runInput` (type: `string`):

Copy of the Actor input used for this run.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("architjn/toolify-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("architjn/toolify-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call architjn/toolify-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,architjn/toolify-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/MiTR4BXNYJnRd43a3/builds/pGqu5A0kOWGvsuqgw/openapi.json