# Fiverr Scraper — Gigs, Sellers, Prices & Market Analysis (`datascoutlab/fiverr-scraper`) Actor

Scrape Fiverr gigs by keyword: title, price, delivery, rating, seller level, country and Pro/Choice badges. Filter by rating, price, level and country, and get a per-search market-analysis summary. No API key, no login

- **URL**: https://apify.com/datascoutlab/fiverr-scraper.md
- **Developed by:** [Anton DataScout](https://apify.com/datascoutlab) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 fiverr gig scrapeds

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Fiverr Scraper — Gigs, Sellers, Prices & Niche Market Analysis

Scrape **Fiverr gigs** for any keyword and get back clean, structured data — gig title, starting price, delivery time, rating, seller level, country and Pro/Choice badges — plus a **per-search market-analysis summary** most Fiverr scrapers don't give you. Filter by rating, price, delivery time, seller level and country before you're billed. **No API key, no login.**

| You give it | You get back |
| --- | --- |
| A keyword (`logo design`, `voice over`, `wordpress developer`) | Every matching Fiverr gig as a clean row — price, delivery, rating, seller |
| `minRating`, `minReviews`, `priceMin/Max`, `maxDeliveryDays` | Only the gigs that match — filtered-out gigs are **not billed** |
| `sellerLevels`, `proOnly`, `sellerCountries` | Just Top Rated / Pro sellers, or only the countries you want |
| `includeMarketSummary` | One summary row per search: total gigs, price percentiles, seller-level mix, top countries |

Built to fix the two things that make other Fiverr scrapers frustrating: they **break under Fiverr's bot protection** (users report constant `429` errors), and they just **dump rows** with no way to filter or make sense of a niche. This one uses rotating residential sessions so runs finish reliably, lets you filter to exactly the gigs you want, and adds a market-analysis layer for niche and pricing research.

### What does the Fiverr Scraper do?

Give it one or more search keywords and it searches Fiverr exactly like a buyer, reads every gig on each results page, paginates through them, and returns each gig as a structured JSON row: title, URL, starting price in USD, delivery days, gig rating and review count, seller username, display name, level, country, languages, Pro and Fiverr's Choice badges, category, and the gig's own attributes (style, file formats, etc.). Turn on the market summary and each search also returns one analytics row describing the whole niche. No Fiverr account, no API key.

### Who uses a Fiverr scraper?

| Audience | What they pull |
| --- | --- |
| **Market & niche researchers** | Total gigs, price percentiles and saturation for any keyword — which niches are crowded, which are open |
| **Freelancers & agencies** | Competitor pricing, delivery times and positioning to price and package their own gigs |
| **Dropshipping & e-commerce** | Reliable service providers by rating, level and delivery speed |
| **VAs & outsourcing teams** | Shortlists of Top Rated / Pro sellers by country, filtered by rating and reviews |
| **Data & AI teams** | Clean gig + seller rows for pricing models, trend analysis and marketplace datasets |

### What data can you extract from Fiverr?

Each gig is one row:

```json
{
  "recordType": "gig",
  "query": "logo design",
  "position": 1,
  "isPromoted": false,
  "gigId": 278023626,
  "title": "design a modern minimalist business logo",
  "url": "https://www.fiverr.com/danii_studio/do-outstanding-logo-design",
  "thumbnail": "https://fiverr-res.cloudinary.com/.../original.png",
  "priceUsd": 25,
  "deliveryDays": 2,
  "packageType": "cheapest",
  "totalPackages": 3,
  "gigRating": 4.9,
  "gigReviewCount": 1607,
  "sellerName": "danii_studio",
  "sellerDisplayName": "Daniyal K",
  "sellerId": 94576129,
  "sellerUrl": "https://www.fiverr.com/danii_studio",
  "sellerLevel": "Level 2",
  "isPro": false,
  "sellerCountry": "PK",
  "sellerOnline": true,
  "sellerRatingScore": 4.91,
  "sellerRatingCount": 1535,
  "sellerLanguages": [{ "code": "en", "level": 3, "proficiency": "Fluent" }],
  "isFiverrChoice": false,
  "offerConsultation": false,
  "hasRecurringOption": true,
  "recurringDiscountPct": 15,
  "categoryId": 3,
  "subCategoryId": 49,
  "attributes": { "style": ["modern"], "file_format": ["ai", "png", "svg"] }
}
````

| Field | Description |
| --- | --- |
| `title` / `url` / `gigId` | Gig title, direct link, and Fiverr's gig ID |
| `priceUsd` / `deliveryDays` / `packageType` | Starting price (USD), delivery time, and which package it is |
| `gigRating` / `gigReviewCount` | The gig's own star rating and number of reviews |
| `sellerName` / `sellerLevel` / `isPro` | Seller username, level (New → Top Rated), and Fiverr Pro flag |
| `sellerCountry` / `sellerOnline` / `sellerLanguages` | Seller's country, online status and spoken languages |
| `sellerRatingScore` / `sellerRatingCount` | The seller's overall rating across all their gigs |
| `isFiverrChoice` / `isPromoted` | Fiverr's Choice badge and whether the gig is a promoted (paid) placement |
| `attributes` | Gig-specific tags Fiverr exposes (style, logo type, file formats, etc.) |

### How to do market research and niche analysis on Fiverr

Leave `includeMarketSummary` on and each search returns one extra `market_summary` row describing the whole niche — the single most useful thing for deciding whether a niche is worth entering:

```json
{
  "recordType": "market_summary",
  "query": "logo design",
  "totalGigsAvailable": 191262,
  "gigsSampled": 44,
  "priceUsd": { "min": 5, "p25": 18.75, "median": 25, "p75": 31.25, "max": 900, "avg": 43.75 },
  "deliveryDays": { "min": 1, "median": 2, "max": 14, "avg": 2.5 },
  "gigRatingAvg": 4.9,
  "avgReviewsPerGig": 1550,
  "sellerLevelMix": { "new_seller": 0, "level_one": 5, "level_two": 35, "top_rated": 4 },
  "proSharePct": 2.3,
  "fiverrChoiceSharePct": 2.3,
  "promotedSharePct": 31.8,
  "topSellerCountries": [{ "country": "PK", "count": 29, "sharePct": 65.9 }]
}
```

Read it at a glance: `logo design` has 191k gigs, a median price of $25 (p75 $31), two-day median delivery, only 2% Pro sellers and two-thirds of sellers in one country — a crowded, low-price niche. Run it across a list of keywords to compare niches by price, saturation and competition before you commit.

### How to filter Fiverr gigs by price, rating and seller level

Every filter is applied before billing, so you only pay for gigs you keep:

- **`minRating` / `minReviews`** — drop unproven gigs; keep only sellers with a track record.
- **`priceMin` / `priceMax`** — target a price band (e.g. $20–$100).
- **`maxDeliveryDays`** — only gigs that deliver fast enough.
- **`sellerLevels`** — keep only `top_rated`, `level_two`, `pro`, etc.
- **`proOnly` / `fiverrChoiceOnly` / `onlineOnly`** — vetted Pro gigs, Fiverr's Choice, or sellers online now.
- **`sellerCountries`** — restrict to specific countries by ISO-2 code (`US`, `GB`, `PK`).

### How to scrape Fiverr gigs — step by step

1. Add one or more keywords to **Search queries** (`logo design`, `voice over`).
2. Set **Max gigs per search** (you're billed per gig kept).
3. Optionally set the **filters** — rating, price, delivery, seller level, country.
4. Run the Actor and export as JSON, CSV or Excel, or pull it via the Apify API.

### Why does this Fiverr scraper not break?

Fiverr is protected by PerimeterX bot detection, which is why many Fiverr scrapers return `429` errors or empty runs. This Actor loads a warmed session through rotating **residential** proxies before each request, so it gets through reliably and fails loudly (with a clear log) instead of silently billing you for nothing. Prices are forced to **USD** so results don't drift with the proxy's location.

### How much does it cost to scrape Fiverr?

You pay per gig returned. Gigs removed by your filters are **not** billed, and the market-summary row makes each run go further — one small run tells you the shape of an entire niche. Start with a low **Max gigs** to test, then scale up.

### How to export Fiverr data to CSV, Excel or Google Sheets

Open the **Dataset** tab and export as CSV, Excel or JSON, or connect the Apify **Google Sheets integration** so each scheduled run appends fresh Fiverr data to a living spreadsheet. Two ready-made table views are included: **Gigs** and **Sellers & ratings**.

### Fiverr API alternative

Fiverr has no public API for browsing gigs or sellers. This Actor is the practical alternative: give it a keyword and get structured gig and seller data — price, rating, delivery, level, country — as JSON or CSV, callable from the Apify API or from AI agents via MCP.

### Input configuration

| Field | Type | Notes |
| --- | --- | --- |
| `queries` | array | Search keywords (one per line) |
| `maxItems` | integer | Max gigs per search (billed per gig kept) |
| `minRating` / `minReviews` | integer | Minimum gig rating / review count |
| `priceMin` / `priceMax` | integer | Price band in USD |
| `maxDeliveryDays` | integer | Only gigs delivering within N days |
| `sellerLevels` | array | `new`, `level_one`, `level_two`, `top_rated`, `pro` |
| `proOnly` / `fiverrChoiceOnly` / `onlineOnly` | boolean | Badge / online filters |
| `sellerCountries` | array | ISO-2 country codes to keep |
| `includeGalleryImages` | boolean | Add every gig portfolio image URL |
| `includeMarketSummary` | boolean | Add the per-search analytics row (default on) |
| `maxPages` | integer | Hard cap on result pages per query |

### Integrations

- **Fiverr data → Google Sheets** — auto-append each run's gigs to a spreadsheet.
- **Fiverr data → Slack / Discord** — get notified when new gigs appear for a keyword.
- **Fiverr data → Make / Zapier** — push gigs into a CRM, sheet or alerting workflow.
- **Fiverr data → BigQuery / Snowflake** — warehouse marketplace data via Airbyte.
- **Scheduled runs & webhooks** — run daily to track how a niche's pricing and competition move over time.

### Use with AI agents via MCP

Callable from AI assistants via Apify's MCP server — ask *"find Top Rated logo-design gigs under $30 delivering in 2 days"* and your assistant runs it and returns structured results.

### Related scrapers

- **App Store Reviews Scraper** — mine app reviews for feature requests and complaints.
- **Google Play Reviews Scraper** — the Android side of the same research.
- **Google Trends (Reliable)** — validate demand for a keyword or niche over time.
- **YouTube Outlier Finder** — find over-performing videos in any niche.
- **KDP Niche Analyzer** — the same "is this niche worth entering?" analysis for Amazon books.

### FAQ

**Do I need a Fiverr account or API key?** No. No login, no key.

**Why do other Fiverr scrapers keep failing with 429 errors?** Fiverr throttles bot-like traffic. Scrapers that don't rotate residential sessions get rate-limited and return empty results. This Actor warms a residential session per request and retries until it gets real data.

**Are prices in USD?** Yes — currency is forced to USD so results are consistent regardless of where the run executes.

**Can I get seller profiles?** This Actor returns the seller data attached to each gig in search (username, level, country, rating, languages, online status). It focuses on gig search, not full standalone profile pages.

**How many gigs can I get?** Up to 48 gigs per page, up to 25 pages per keyword (~1,200 gigs). Run multiple keywords for more coverage.

### Disclaimer

This Actor is not affiliated with, endorsed by, or sponsored by Fiverr. "Fiverr" is a trademark of Fiverr International Ltd. It accesses only publicly available search data that any visitor can see. Comply with Fiverr's Terms of Service and applicable law (GDPR, CCPA); do not use scraped personal data without a legitimate basis.

### SEO Keywords

fiverr scraper, fiverr gig scraper, scrape fiverr, fiverr api, fiverr api alternative, fiverr data extraction, fiverr gig data, fiverr seller data, freelance marketplace scraper, gig economy data, fiverr market research, fiverr niche research, fiverr competitor analysis, fiverr price comparison, fiverr pricing data, fiverr rating scraper, fiverr to csv, fiverr to excel, export fiverr data, no-code fiverr scraper, apify fiverr, fiverr search scraper, fiverr gig search, scrape fiverr gigs by keyword

# Actor input Schema

## `queries` (type: `array`):

What to search on Fiverr, e.g. `logo design`, `wordpress developer`, `voice over`. One per line — each is searched separately.

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

Cap the number of gigs collected per query. You are billed per gig returned — gigs removed by the filters below are NOT billed.

## `minRating` (type: `integer`):

Only gigs with at least this star rating (1–5). Leave empty for all.

## `minReviews` (type: `integer`):

Only gigs with at least this many reviews — filters out brand-new, unproven gigs.

## `priceMin` (type: `integer`):

Only gigs whose starting price is at least this many USD.

## `priceMax` (type: `integer`):

Only gigs whose starting price is at most this many USD.

## `maxDeliveryDays` (type: `integer`):

Only gigs that deliver within this many days.

## `sellerLevels` (type: `array`):

Keep only these seller levels. Leave empty for all levels.

## `proOnly` (type: `boolean`):

Keep only vetted Fiverr Pro gigs.

## `fiverrChoiceOnly` (type: `boolean`):

Keep only gigs badged as Fiverr's Choice.

## `onlineOnly` (type: `boolean`):

Keep only gigs whose seller is currently online.

## `sellerCountries` (type: `array`):

Keep only sellers from these countries (ISO-2 codes, e.g. `US`, `GB`, `PK`). Leave empty for all.

## `includeGalleryImages` (type: `boolean`):

Add every gig portfolio image URL to each row (larger output).

## `includeMarketSummary` (type: `boolean`):

Add one `market_summary` row per query: total gigs available, price percentiles, seller-level mix, top seller countries, Pro/Choice share. Great for niche and pricing research.

## `maxPages` (type: `integer`):

Hard cap on result pages fetched per query (48 gigs per page). Leave empty to page until Max gigs is reached (max 25 pages).

## Actor input object example

```json
{
  "queries": [
    "logo design"
  ],
  "maxItems": 100,
  "proOnly": false,
  "fiverrChoiceOnly": false,
  "onlineOnly": false,
  "includeGalleryImages": false,
  "includeMarketSummary": true
}
```

# Actor output Schema

## `results` (type: `string`):

Gigs with seller level, rating, review count and starting price.

## `resultsCsv` (type: `string`):

The same rows as CSV — open in Excel or pull into Google Sheets with IMPORTDATA().

# 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 = {
    "queries": [
        "logo design"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutlab/fiverr-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 = { "queries": ["logo design"] }

# Run the Actor and wait for it to finish
run = client.actor("datascoutlab/fiverr-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 '{
  "queries": [
    "logo design"
  ]
}' |
apify call datascoutlab/fiverr-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fiverr Scraper — Gigs, Sellers, Prices & Market Analysis",
        "description": "Scrape Fiverr gigs by keyword: title, price, delivery, rating, seller level, country and Pro/Choice badges. Filter by rating, price, level and country, and get a per-search market-analysis summary. No API key, no login",
        "version": "0.1",
        "x-build-id": "gLhvLI1YlwqMPSbdD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascoutlab~fiverr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascoutlab-fiverr-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/datascoutlab~fiverr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascoutlab-fiverr-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/datascoutlab~fiverr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascoutlab-fiverr-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries / keywords",
                        "type": "array",
                        "description": "What to search on Fiverr, e.g. `logo design`, `wordpress developer`, `voice over`. One per line — each is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max gigs per search",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Cap the number of gigs collected per query. You are billed per gig returned — gigs removed by the filters below are NOT billed.",
                        "default": 100
                    },
                    "minRating": {
                        "title": "Minimum gig rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only gigs with at least this star rating (1–5). Leave empty for all."
                    },
                    "minReviews": {
                        "title": "Minimum review count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only gigs with at least this many reviews — filters out brand-new, unproven gigs."
                    },
                    "priceMin": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only gigs whose starting price is at least this many USD."
                    },
                    "priceMax": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only gigs whose starting price is at most this many USD."
                    },
                    "maxDeliveryDays": {
                        "title": "Maximum delivery days",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only gigs that deliver within this many days."
                    },
                    "sellerLevels": {
                        "title": "Seller levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only these seller levels. Leave empty for all levels.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "new",
                                "level_one",
                                "level_two",
                                "top_rated",
                                "pro"
                            ],
                            "enumTitles": [
                                "New Seller",
                                "Level 1",
                                "Level 2",
                                "Top Rated Seller",
                                "Fiverr Pro"
                            ]
                        }
                    },
                    "proOnly": {
                        "title": "Fiverr Pro sellers only",
                        "type": "boolean",
                        "description": "Keep only vetted Fiverr Pro gigs.",
                        "default": false
                    },
                    "fiverrChoiceOnly": {
                        "title": "Fiverr's Choice gigs only",
                        "type": "boolean",
                        "description": "Keep only gigs badged as Fiverr's Choice.",
                        "default": false
                    },
                    "onlineOnly": {
                        "title": "Online sellers only",
                        "type": "boolean",
                        "description": "Keep only gigs whose seller is currently online.",
                        "default": false
                    },
                    "sellerCountries": {
                        "title": "Seller countries",
                        "type": "array",
                        "description": "Keep only sellers from these countries (ISO-2 codes, e.g. `US`, `GB`, `PK`). Leave empty for all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeGalleryImages": {
                        "title": "Include gallery images",
                        "type": "boolean",
                        "description": "Add every gig portfolio image URL to each row (larger output).",
                        "default": false
                    },
                    "includeMarketSummary": {
                        "title": "Include market-analysis summary",
                        "type": "boolean",
                        "description": "Add one `market_summary` row per query: total gigs available, price percentiles, seller-level mix, top seller countries, Pro/Choice share. Great for niche and pricing research.",
                        "default": true
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Hard cap on result pages fetched per query (48 gigs per page). Leave empty to page until Max gigs is reached (max 25 pages)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
