# Behance + Dribbble Scraper (`crawlerbros/behance-dribbble-scraper`) Actor

Scrape designer profiles from Behance and Dribbble with display name, location, occupation, avatar, follower stats, project/shot counts, work-experience history, social links, and current availability flag.

- **URL**: https://apify.com/crawlerbros/behance-dribbble-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Behance + Dribbble Scraper

Scrape designer profiles, individual projects/shots, search results, trending lists, and creative-field categories from **Behance** (Adobe-owned, deeper data) and **Dribbble** (lighter data — JS-rendered). Single actor with a `mode` + `platform` switch. No login required.

### Modes

| Mode | What it does |
| --- | --- |
| `designerProfile` | Look up one or more designers by username (or full profile URL) — display name, occupation, location, follower stats, work history, social links, availability flag |
| `projectByUrl` | Fetch a single Behance gallery (`/gallery/<id>/<slug>`) or Dribbble shot (`/shots/<id>-<slug>`) by full URL |
| `projectSearch` | Search projects/shots by free-text query, optionally filtered by Behance creative field, tool, or sort order |
| `trendingProjects` | Pull popular galleries from Behance (`/galleries`) or popular shots from Dribbble (`/shots/popular`, by timeframe) |
| `byCategory` | Browse projects in a Behance creative-field taxonomy (e.g. `ui-ux`, `branding`) or a Dribbble tag |

### What you get

#### Designer records (`recordType=designer`)

Common fields (both platforms):

| Field | Description |
| --- | --- |
| `platform` | `behance` or `dribbble` |
| `username` | Designer handle |
| `id` | Same as `username` (or numeric Behance ID) |
| `url` | Public profile URL |
| `displayName` | Display name |
| `bio` | Profile bio (Dribbble) / occupation (Behance) |
| `avatarUrl` | Avatar image URL |
| `scrapedAt` | ISO 8601 UTC timestamp |

Behance-only fields:

| Field | Description |
| --- | --- |
| `firstName`, `lastName` | Given / family name |
| `occupation` | Job title |
| `city`, `country` | Location |
| `bannerImageUrl` | Profile banner image URL |
| `followersCount`, `followingCount` | Follower / following counts |
| `appreciationsCount` | Total appreciations across projects |
| `viewsCount` | Total project views |
| `projectsCount` | Total published projects |
| `webLinks` | Array of `{url, title}` external links |
| `socialLinks` | Array of `{service, url, username}` social profiles |
| `workExperience` | Array of `{company, position, startDate, endDate, currentlyWorking}` |
| `availableForHire` | `true` if the designer flagged availability |
| `workType` | `Freelance` / `FullTime` |
| `isFeaturedFreelancer` | Behance "Featured Freelancer" badge |
| `isCreatorPro` | Behance Creator Pro flag |
| `createdOn` | ISO 8601 account-creation timestamp |

Empty fields are dropped from every record at every depth.

#### Project / shot records (`recordType=project` for Behance, `recordType=shot` for Dribbble)

| Field | Description |
| --- | --- |
| `id` | Behance gallery ID / Dribbble shot ID |
| `name` | Project / shot title |
| `slug` | URL slug |
| `url` | Public URL |
| `description` | Project description (or Dribbble shot description) |
| `coverImageUrl` | Cover image URL |
| `appreciationsCount`, `viewsCount`, `commentsCount` | Engagement counts (Behance) |
| `tags` | Free-form keyword tags |
| `creativeFields` | Behance creative-field taxonomy labels |
| `tools` | Tools listed on the project (Photoshop, Figma, …) |
| `owners` | Array of `{username, displayName, url}` |
| `publishedOn` / `modifiedOn` | Timestamps (Behance integer, Dribbble ISO string) |

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | Enum | `projectByUrl` | `designerProfile` / `projectByUrl` / `projectSearch` / `trendingProjects` / `byCategory` |
| `platform` | Enum | `behance` | `behance` or `dribbble` (used by every mode except `projectByUrl`, where the URL itself encodes the platform) |
| `usernames` | Array | `["michaelsallit"]` | Handles or full profile URLs (`mode=designerProfile`) |
| `urls` | Array | sample gallery URL | Behance gallery or Dribbble shot URLs (`mode=projectByUrl`) |
| `query` | String | — | Free-text search query (`mode=projectSearch`) |
| `behanceField` | Enum | — | Behance creative-field slug (e.g. `ui-ux`, `logo-design`). Used in `projectSearch` + `byCategory` |
| `behanceTool` | Enum | — | Filter Behance projects by tool (`figma`, `photoshop`, …) |
| `behanceSort` | Enum | — | Behance sort order (`appreciations` / `views` / `comments` / `published_date` / `featured_date`) |
| `dribbbleTimeframe` | Enum | — | Dribbble trending window (`now` / `week` / `month` / `year` / `ever`) |
| `dribbbleTag` | String | — | Dribbble tag slug (`mode=byCategory` on Dribbble) |
| `minFollowers` | Integer | — | Drop profiles below this follower count (`mode=designerProfile`, Behance only) |
| `availableForHireOnly` | Boolean | `false` | Drop Behance profiles without an availability flag |
| `maxItems` | Integer | `50` | Hard cap on emitted records (1-1000) |
| `autoEscalateOnBlock` | Boolean | `true` | Engage Apify Proxy on first 403 block |

#### Example input — Behance batch with hire filter

```json
{
  "platform": "behance",
  "usernames": ["alexcoven", "matiasdeangelis", "annaholiday"],
  "availableForHireOnly": true,
  "minFollowers": 1000,
  "maxItems": 100
}
````

#### Example input — Dribbble lookup

```json
{
  "platform": "dribbble",
  "usernames": ["aaron", "simple", "MBKHD"]
}
```

### Example output (Behance)

```json
{
  "recordType": "designer",
  "platform": "behance",
  "id": "12345678",
  "username": "alexcoven",
  "url": "https://www.behance.net/alexcoven",
  "displayName": "Alex Covenn",
  "occupation": "Award Winning Logo Designer",
  "avatarUrl": "https://pps.services.adobe.com/api/profile/image/.../276",
  "followersCount": 1500,
  "followingCount": 200,
  "appreciationsCount": 5000,
  "viewsCount": 120000,
  "projectsCount": 12,
  "availableForHire": true,
  "workType": "Freelance",
  "webLinks": [
    { "url": "https://x.com/user", "title": "Twitter" }
  ],
  "workExperience": [
    { "company": "Acme", "position": "Designer", "startDate": "2020", "currentlyWorking": true }
  ],
  "scrapedAt": "2026-05-06T07:01:18Z"
}
```

### Use cases

- **Recruiting / staffing** — Build a designer-talent database with availability + skill tags.
- **Lead generation** — Identify designers with N+ followers who are open to freelance work.
- **Competitive research** — Track top designers in a niche (logo, illustration, UX, …).
- **CRM enrichment** — Augment designer leads with public Behance/Dribbble stats.
- **Industry analysis** — Snapshot the designer-platform follower / project ecosystems.

### FAQ

**Do I need an Adobe / Dribbble account?**
No. Both platforms serve their public profile pages anonymously.

**Why does Behance return more data than Dribbble?**
Behance's profile pages embed a server-side-rendered JSON blob (`beconfig-store_state`) with full structured data — stats, work history, social links, availability flag. Dribbble's pages are JS-rendered; without executing JS we can only extract OG meta tags (display name, bio, avatar). For richer Dribbble data, we'd need Playwright (heavier to run); this v1 keeps the actor lightweight.

**Why TLS impersonation?**
Both Behance (Adobe Edge CDN) and Dribbble (Cloudflare) fingerprint the TLS handshake. We use `curl_cffi` Chrome-131 impersonation so the actor passes through both WAFs without proxy or session warmup.

**What if a username doesn't exist?**
The actor logs a warning and continues to the next username. Final status message lists how many records were emitted.

**How current is the data?**
Live — every run hits the platform at request time. Schedule the actor for daily / weekly refreshes to track follower growth.

**Do I need a proxy?**
No. Both platforms accept datacenter IPs as long as the TLS fingerprint is real (which Chrome-131 impersonation provides).

**What if the platform does block me?**
The actor has built-in auto-escalation: on the first HTTP 403 / anti-bot block it lazily engages Apify Proxy (datacenter group first, residential as a second-stage fallback) and retries the failed URL transparently. All subsequent fetches in the same run continue through the proxied session. To disable, set `autoEscalateOnBlock=false`. To force a specific group set, populate `proxyGroups`.

### Limitations

- Dribbble profiles return only display name, bio, and avatar (the rest of the page is JS-rendered).
- Behance projects (the actual portfolio items) aren't included in this version — only the profile metadata.
- Both platforms periodically update their HTML; if a future redesign breaks `beconfig-store_state`, we'll bump the actor.
- TLS-fingerprint maintenance: `curl_cffi` updates Chrome impersonation profiles regularly; we follow upstream.

# Actor input Schema

## `mode` (type: `string`):

What to scrape.

## `platform` (type: `string`):

Which platform to scrape. Used by every mode except `projectByUrl` (where the URL itself encodes the platform).

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

Designer handles or full profile URLs (e.g. `michaelsallit`, `https://www.behance.net/michaelsallit`, `https://dribbble.com/aaron`).

## `urls` (type: `array`):

Behance gallery URLs (`https://www.behance.net/gallery/<id>/<slug>`) or Dribbble shot URLs (`https://dribbble.com/shots/<id>-<slug>`).

## `query` (type: `string`):

Free-text search query. Required for Dribbble; optional on Behance if a `behanceField` or `behanceTool` is given.

## `behanceField` (type: `string`):

Behance creative-field taxonomy. Filters projects by topical area. Required for `mode=byCategory` on Behance.

## `behanceTool` (type: `string`):

Filter projects to those tagged with a specific creative tool.

## `behanceSort` (type: `string`):

Sort order for Behance project search results.

## `dribbbleTimeframe` (type: `string`):

Time window for Dribbble trending shots.

## `dribbbleTag` (type: `string`):

Dribbble tag slug (e.g. `branding`, `mobile`, `web-design`). Required for `mode=byCategory` on Dribbble.

## `minFollowers` (type: `integer`):

Drop profiles with fewer followers than this. Behance only — Dribbble doesn't expose counts in HTML.

## `availableForHireOnly` (type: `boolean`):

Drop Behance profiles that don't have an active availability flag.

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

Hard cap on emitted records.

## `autoEscalateOnBlock` (type: `boolean`):

If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 / anti-bot blocks from a raw datacenter IP. Set false to disable (request fails fast).

## `proxyGroups` (type: `array`):

Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then residential fallback.

## Actor input object example

```json
{
  "mode": "projectByUrl",
  "platform": "behance",
  "usernames": [
    "michaelsallit"
  ],
  "urls": [
    "https://www.behance.net/gallery/197889857/Modern-Logo-Design-Branding-Identity"
  ],
  "availableForHireOnly": false,
  "maxItems": 50,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset of all scraped designer profiles.

# 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 = {
    "mode": "projectByUrl",
    "platform": "behance",
    "urls": [
        "https://www.behance.net/gallery/197889857/Modern-Logo-Design-Branding-Identity"
    ],
    "availableForHireOnly": false,
    "maxItems": 50,
    "autoEscalateOnBlock": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/behance-dribbble-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 = {
    "mode": "projectByUrl",
    "platform": "behance",
    "urls": ["https://www.behance.net/gallery/197889857/Modern-Logo-Design-Branding-Identity"],
    "availableForHireOnly": False,
    "maxItems": 50,
    "autoEscalateOnBlock": True,
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "projectByUrl",
  "platform": "behance",
  "urls": [
    "https://www.behance.net/gallery/197889857/Modern-Logo-Design-Branding-Identity"
  ],
  "availableForHireOnly": false,
  "maxItems": 50,
  "autoEscalateOnBlock": true
}' |
apify call crawlerbros/behance-dribbble-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Behance + Dribbble Scraper",
        "description": "Scrape designer profiles from Behance and Dribbble with display name, location, occupation, avatar, follower stats, project/shot counts, work-experience history, social links, and current availability flag.",
        "version": "1.0",
        "x-build-id": "38K39Rj4eyIGrJYcb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~behance-dribbble-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-behance-dribbble-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/crawlerbros~behance-dribbble-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-behance-dribbble-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/crawlerbros~behance-dribbble-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-behance-dribbble-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "designerProfile",
                            "projectByUrl",
                            "projectSearch",
                            "trendingProjects",
                            "byCategory"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "projectByUrl"
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "behance",
                            "dribbble"
                        ],
                        "type": "string",
                        "description": "Which platform to scrape. Used by every mode except `projectByUrl` (where the URL itself encodes the platform).",
                        "default": "behance"
                    },
                    "usernames": {
                        "title": "Usernames or profile URLs (mode=designerProfile)",
                        "type": "array",
                        "description": "Designer handles or full profile URLs (e.g. `michaelsallit`, `https://www.behance.net/michaelsallit`, `https://dribbble.com/aaron`).",
                        "default": [
                            "michaelsallit"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Project URLs (mode=projectByUrl)",
                        "type": "array",
                        "description": "Behance gallery URLs (`https://www.behance.net/gallery/<id>/<slug>`) or Dribbble shot URLs (`https://dribbble.com/shots/<id>-<slug>`).",
                        "default": [
                            "https://www.behance.net/gallery/197889857/Modern-Logo-Design-Branding-Identity"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Search query (mode=projectSearch)",
                        "type": "string",
                        "description": "Free-text search query. Required for Dribbble; optional on Behance if a `behanceField` or `behanceTool` is given."
                    },
                    "behanceField": {
                        "title": "Behance creative field (mode=projectSearch / byCategory)",
                        "enum": [
                            "graphic-design",
                            "ui-ux",
                            "photography",
                            "illustration",
                            "branding",
                            "motion-graphics",
                            "industrial-design",
                            "architecture",
                            "web-design",
                            "typography",
                            "3d-art",
                            "animation",
                            "fashion",
                            "advertising",
                            "art-direction",
                            "fine-arts",
                            "game-design",
                            "interaction-design",
                            "package-design",
                            "print-design",
                            "character-design",
                            "digital-art",
                            "drawing",
                            "editorial-design",
                            "icon-design",
                            "logo-design",
                            "music-design",
                            "painting",
                            "product-design",
                            "ui-design",
                            "user-experience",
                            "ux-design",
                            "video-design",
                            "visual-design",
                            "vr-ar"
                        ],
                        "type": "string",
                        "description": "Behance creative-field taxonomy. Filters projects by topical area. Required for `mode=byCategory` on Behance."
                    },
                    "behanceTool": {
                        "title": "Behance tool (mode=projectSearch)",
                        "enum": [
                            "photoshop",
                            "illustrator",
                            "figma",
                            "xd",
                            "after-effects",
                            "cinema-4d",
                            "blender",
                            "procreate",
                            "sketch",
                            "indesign",
                            "lightroom",
                            "premiere-pro",
                            "autodesk-maya",
                            "3ds-max",
                            "zbrush",
                            "substance-painter",
                            "davinci-resolve",
                            "final-cut-pro",
                            "audition",
                            "animate",
                            "fresco",
                            "dimension",
                            "character-animator",
                            "framer",
                            "principle",
                            "invision",
                            "marvelapp",
                            "axure",
                            "balsamiq",
                            "miro",
                            "notion",
                            "webflow",
                            "figjam",
                            "midjourney",
                            "dall-e",
                            "stable-diffusion"
                        ],
                        "type": "string",
                        "description": "Filter projects to those tagged with a specific creative tool."
                    },
                    "behanceSort": {
                        "title": "Behance sort (mode=projectSearch)",
                        "enum": [
                            "appreciations",
                            "views",
                            "comments",
                            "published_date",
                            "featured_date"
                        ],
                        "type": "string",
                        "description": "Sort order for Behance project search results."
                    },
                    "dribbbleTimeframe": {
                        "title": "Dribbble timeframe (mode=trendingProjects on Dribbble)",
                        "enum": [
                            "now",
                            "week",
                            "month",
                            "year",
                            "ever"
                        ],
                        "type": "string",
                        "description": "Time window for Dribbble trending shots."
                    },
                    "dribbbleTag": {
                        "title": "Dribbble tag (mode=byCategory on Dribbble)",
                        "type": "string",
                        "description": "Dribbble tag slug (e.g. `branding`, `mobile`, `web-design`). Required for `mode=byCategory` on Dribbble."
                    },
                    "minFollowers": {
                        "title": "Min followers (mode=designerProfile)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop profiles with fewer followers than this. Behance only — Dribbble doesn't expose counts in HTML."
                    },
                    "availableForHireOnly": {
                        "title": "Available-for-hire only (mode=designerProfile, Behance)",
                        "type": "boolean",
                        "description": "Drop Behance profiles that don't have an active availability flag.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on block",
                        "type": "boolean",
                        "description": "If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 / anti-bot blocks from a raw datacenter IP. Set false to disable (request fails fast).",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then residential fallback.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
