# Etsy Listings Scraper — Bulk Search, Ads & Organic Rank (`astravalabs/etsy-listings-scraper`) Actor

Scrape Etsy search results for up to 50 keywords and 30 pages each. Export 36 fields per listing, including prices, shop metrics, sponsored placement, organic rank, badges, color variants, video, and localized market data.

- **URL**: https://apify.com/astravalabs/etsy-listings-scraper.md
- **Developed by:** [Astrava Labs](https://apify.com/astravalabs) (community)
- **Categories:** E-commerce, Lead generation, Developer tools
- **Stats:** 7 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

## Etsy Listings Scraper — Bulk Search, Ads & Organic Rank

Scrape Etsy search results in bulk and compare organic placement with sponsored
slots. Each saved listing contains 36 search-result fields covering pricing,
shop metrics, badges, product type, color variants, and video.

Accepts up to 50 keywords per run, processes up to 16 concurrently, and fetches up to two pages per keyword at once (32 page requests globally). The first page often yields around 10–15 listings; later full pages yield roughly 64.

No proxy setup required. No captcha-solving service needed. Proxies are bundled — just provide keywords and run.

**Simple pay-per-result pricing** (see the price above). Platform usage and
proxies are included, with no separate compute or proxy charge.

### Why use this actor?

- **Bulk keyword research:** up to 50 keywords and 30 pages per keyword in one run.
- **Organic versus paid placement:** `rank`, `organic_rank`, `is_ad`, and `ad_slot` expose what Etsy surfaced organically and as sponsored results.
- **Localized research:** compare pricing and result composition across 32 markets.
- **Search-result efficiency:** collect shop, pricing, badge, variant, and media signals without visiting every product page.
- **Predictable output cost:** `maxTotalResults` places one exact cap across the whole run, even when many keywords execute concurrently.

This actor is intentionally focused on search-result intelligence. It does not
visit every listing page for descriptions, tags, materials, complete image
galleries, or reviews. Use the companion
[Etsy Product Scraper](https://apify.com/astravalabs/etsy-product-scraper) when
you need full product-page enrichment.

### Quick start

```json
{
  "keywords": ["personalized necklace", "custom mug", "wall art print"],
  "maxPages": 5,
  "maxTotalResults": 1000,
  "country": "US"
}
````

Three keywords and up to roughly 800 listings total. The run-wide cap guarantees
that no more than 1,000 listing rows will be saved. Actual yield and runtime vary
with Etsy availability and proxy response times.

### Etsy listing data — 36 fields per result

**Search context** — the keyword that surfaced the listing, its position in results (`rank`), its organic rank excluding ads (`organic_rank`), and the page it appeared on.

**Listing** — `listing_id`, `title`, direct `url`, and `image_url`.

**Shop** — `shop_name`, `shop_id`, `shop_url`, star rating (`shop_rating`), total review count (`shop_review_count`), and years on Etsy (`shop_age_years`).

**Pricing** — `price`, `currency`, `original_price`, `discount_pct`, `is_on_sale`, `is_free_shipping`.

**Ad placement** — `is_ad`, `ad_slot` (position of the sponsored listing on the page).

**Badges** — `is_bestseller`, `is_popular_now`, `is_etsys_pick`, `is_star_seller`, `is_limited_stock`.

**Product type** — `is_digital`, `has_personalization`.

**Media** — `has_video`, `video_url`, `color_variant_count`, `color_variants` (list of color names shown in swatches).

**Logistics** — `ships_from`, when Etsy displays a seller-origin label on the
localized search card. This signal is sparse and market-dependent; `null` means
Etsy did not expose the origin in search results, not that the listing ships
from the selected country.

**Meta** — `total_result_count` (Etsy's total for the keyword), `scraped_at`.

### Search filters & input options

| Field | Default | Description |
|---|---|---|
| `keywords` | — | 1–50 search terms, batched in one run |
| `maxPages` | 5 | Pages to scrape per keyword (1–30). The first page is smaller; later pages yield ~64 listings each. |
| `country` | US | 32 countries — sets locale, language, and currency |
| `sortOrder` | Most relevant | Most relevant, Price low→high, Price high→low, Top reviews, Newest |
| `minPrice` | — | Minimum price in the selected country's currency |
| `maxPrice` | — | Maximum price in the selected country's currency |
| `maxResults` | — | Cap listings per keyword. Leave empty for no cap. |
| `maxTotalResults` | — | Exact cap on saved listings across the entire run. Leave empty for no run-wide cap. |

**Filters:** `onSale`, `freeShipping`, `starSeller`, `customizable`, `etsyPick`, `listingType` (all / digital / physical), `excludeSponsored` to drop ads from output.

### Etsy scraping use cases

**Niche research.** Run 20 keyword variants in one go, sort by `organic_rank`, see what Etsy's algorithm pushes organically versus what sellers are paying to promote.

```json
{
  "keywords": ["mushroom lamp", "fungi lamp", "cottagecore lamp", "morel lamp"],
  "maxPages": 10,
  "excludeSponsored": true
}
```

**Competitor ad mapping.** Pull a keyword and filter results where `is_ad: true`
— you get the sponsored listings Etsy surfaced in the captured result pages,
including their slot positions at scrape time.

```json
{
  "keywords": ["personalized mug"],
  "maxPages": 5,
  "sortOrder": "most_relevant"
}
```

**Pricing teardowns.** Combine `minPrice` / `maxPrice` with `sortOrder: price_desc` to slice a niche by price tier and see how sellers position across the curve.

```json
{
  "keywords": ["linen dress", "boho dress"],
  "maxPages": 10,
  "minPrice": 50,
  "sortOrder": "price_desc"
}
```

**Localized market research.** The same keyword often surfaces an entirely different competitive landscape by country. Run the same terms across US, GB, and DE to compare.

```json
{
  "keywords": ["handmade candle", "soy candle"],
  "maxPages": 10,
  "country": "GB"
}
```

**Star Seller landscape.** Filter to top-rated shops only and sort by review count to benchmark the most established players in a niche.

```json
{
  "keywords": ["enamel pin"],
  "maxPages": 15,
  "starSeller": true,
  "sortOrder": "highest_reviews"
}
```

### Output

Listings land in the **default dataset** (one row per listing, nothing else) — export as JSON, CSV, Excel, or JSONL from the Apify console or via API.

Per-keyword status and run totals land in the **key-value store** under
`RUN_REPORT`: for each keyword, pages fetched, listing count, whether it
completed, and any run-wide stop reason. The summary records whether
`maxTotalResults` or the Apify spending limit stopped the run.

### Sample row

A real listing from a `mug` keyword run — overall rank 3, organic rank 2, 50% off, 21,500 reviews, and 8 color variants.

```json
{
  "keyword": "mug",
  "page": 1,
  "rank": 3,
  "organic_rank": 2,
  "listing_id": "4384679177",
  "title": "Custom Photo Collage Mug, Your Photo, Your Text, Personalized Photo Mug, Custom Coffee Cup Gift for Family and Friend, Memory Keepsake",
  "url": "https://www.etsy.com/listing/4384679177/custom-photo-collage-mug-your-photo-your",
  "image_url": "https://i.etsystatic.com/30637927/r/il/715b79/8042175906/il_1588xN.8042175906_ijkp.jpg",
  "shop_name": "ArtsifOfficial",
  "shop_id": 30637927,
  "shop_url": "https://www.etsy.com/shop/ArtsifOfficial",
  "shop_rating": 4.9,
  "shop_review_count": 21500,
  "shop_age_years": 4.0,
  "price": 6.99,
  "currency": "USD",
  "original_price": 13.99,
  "discount_pct": 50,
  "is_on_sale": true,
  "is_free_shipping": false,
  "is_ad": false,
  "ad_slot": null,
  "is_bestseller": false,
  "is_popular_now": true,
  "is_etsys_pick": false,
  "is_star_seller": false,
  "is_limited_stock": false,
  "is_digital": false,
  "has_personalization": true,
  "has_video": true,
  "video_url": "https://v.etsystatic.com/video/upload/ac_none,du_15,q_auto:good/tfadzvtf7adbe63cipsx.mp4",
  "color_variant_count": 8,
  "color_variants": ["Green", "Red", "Dark blue", "Purple", "Black", "Yellow", "Light blue", "Pink"],
  "ships_from": null,
  "total_result_count": 3061962,
  "scraped_at": "2026-06-29T21:37:43.489448+00:00"
}
```

### Speed & scale

Measured locally on 2026-07-17 through SmartProxy, with one sticky proxy
session per keyword. Times include proxy warmup and retries:

| Run shape | Time | Listings |
|---|---|---|
| 1 keyword, 1 page | 4.7s | 10 |
| 1 keyword, 5 pages | 9.4s | 258 |
| 1 keyword, 10 pages | 12.7s | 580 |
| 3 keywords parallel, 3 pages each | 7.9s | 406 |
| 5 keywords parallel, 5 pages each | 9.4s | 1,319 |
| 10 keywords parallel, 5 pages each | 18.0s | 2,646 |
| 50 keywords, up to 30 pages each (max scale) | 5m 29.2s | 63,840 |

**Why your row count may be below `maxPages × 64`.** The first page is typically smaller than later pages, and Etsy's index caps most keyword searches at around 20–22 pages of results (~1,200–1,400 listings), regardless of how many pages you request. The scraper stops cleanly when Etsy's pagination is exhausted — you won't be charged for empty pages. For broad or trending keywords, `maxPages: 30` is the right ceiling; for niche terms, 10–15 is usually enough.

#### Controlling the total result count and cost

Use `maxTotalResults` when the total dataset size matters more than how rows are
distributed across keywords. The persistence layer applies it to the combined
output from all concurrent workers, so the final dataset never exceeds the cap.
At the current $4 per 1,000 listings price, the listing charge ceiling is:

```text
maxTotalResults × $0.004
```

For example, `maxTotalResults: 5000` limits listing charges to $20. The actor may
fetch some concurrent pages that are not saved after the cap is reached, but
those discarded rows are not charged as dataset results.

`maxResults` and `maxTotalResults` can be combined: the first caps each keyword,
while the second caps the complete run.

**Large runs and Apify spending limits.** A pay-per-result run also stops cleanly
when its Apify maximum charge is reached, so an Actor run can finish successfully
with partial results. For an uncapped full scrape, leave `maxTotalResults` empty,
set a sufficient maximum charge, and verify that every entry in
`RUN_REPORT.keywords` has `completed: true`.

`maxPages` caps at 30.

### FAQ

**Is it legal to scrape Etsy?**
This scraper only collects data from public Etsy search-results pages — no login, no private or personal buyer data. Scraping publicly available information is generally permitted, but you are responsible for how you use the data; review Etsy's Terms of Service and any regulations that apply to you.

**Do I need proxies or a captcha solver?**
No. Proxies are bundled and rotated automatically, and there's no captcha-solving service to configure. Provide keywords and run.

**Is there a free Etsy scraper?**
New Apify accounts include monthly free platform credits, so you can trial this
Etsy scraper using those credits. After that, see the current pay-per-result
price shown above; platform usage and proxies are included.

**Can I export Etsy listings to CSV or Excel?**
Yes. Every run writes to a dataset you can export as CSV, Excel, JSON, or JSONL from the Apify console or via the API.

**How many listings can I scrape per keyword?**
Etsy caps most keyword searches at ~20–22 pages (roughly 1,200–1,400 listings). The scraper stops cleanly when pagination is exhausted, so you're never charged for empty pages.

**Can I scrape a single Etsy product page, a whole shop, or buyer reviews?**
Yes — use the companion actors: [Etsy Product Scraper](https://apify.com/astravalabs/etsy-product-scraper) for full product-page detail by URL, [Etsy Shop Catalog Scraper](https://apify.com/astravalabs/etsy-shop-catalog-scraper) for an entire shop's catalog, [Etsy Reviews Scraper](https://apify.com/astravalabs/etsy-reviews-scraper) for buyer reviews, and the [Etsy Keyword Research Tool](https://apify.com/astravalabs/etsy-keyword-research-tool) for keyword ideas.

***

> ⚠️ Unofficial. This actor is not affiliated with, endorsed by, or sponsored by Etsy, Inc. "Etsy" is a trademark of Etsy, Inc., used here for descriptive purposes only.

# Actor input Schema

## `keywords` (type: `array`):

List of search keywords to scrape.

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

Number of Etsy search result pages to scrape per keyword. The first page is smaller; later pages yield ~64 listings each.

## `country` (type: `string`):

ISO-3166 country code for localized search results and currency.

## `minPrice` (type: `number`):

Filter listings to this minimum price (in the selected country's currency).

## `maxPrice` (type: `number`):

Filter listings to this maximum price (in the selected country's currency).

## `maxResults` (type: `integer`):

Stop collecting listings for a keyword once this many are gathered. Leave empty for no cap.

## `maxTotalResults` (type: `integer`):

Stop the entire run after this many listings have been saved across all keywords. Leave empty for no run-wide cap.

## `sortOrder` (type: `string`):

How to sort the search results.

## `listingType` (type: `string`):

Filter by listing type.

## `onSale` (type: `boolean`):

Return only discounted / sale listings.

## `freeShipping` (type: `boolean`):

Return only listings that offer free shipping.

## `starSeller` (type: `boolean`):

Return only listings from Star Seller shops.

## `customizable` (type: `boolean`):

Return only listings that accept customization.

## `etsyPick` (type: `boolean`):

Return only listings curated by Etsy (merch library).

## `excludeSponsored` (type: `boolean`):

Strip ad/sponsored listings from results. Sponsored listings are still fetched but not saved.

## Actor input object example

```json
{
  "keywords": [
    "handmade candle"
  ],
  "maxPages": 5,
  "country": "US",
  "sortOrder": "most_relevant",
  "listingType": "all",
  "onSale": false,
  "freeShipping": false,
  "starSeller": false,
  "customizable": false,
  "etsyPick": false,
  "excludeSponsored": false
}
```

# Actor output Schema

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

Default dataset containing one record per Etsy listing scraped from the search results.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "handmade candle"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("astravalabs/etsy-listings-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 = { "keywords": ["handmade candle"] }

# Run the Actor and wait for it to finish
run = client.actor("astravalabs/etsy-listings-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 '{
  "keywords": [
    "handmade candle"
  ]
}' |
apify call astravalabs/etsy-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Listings Scraper — Bulk Search, Ads & Organic Rank",
        "description": "Scrape Etsy search results for up to 50 keywords and 30 pages each. Export 36 fields per listing, including prices, shop metrics, sponsored placement, organic rank, badges, color variants, video, and localized market data.",
        "version": "0.0",
        "x-build-id": "313XohJZHsMjvReGH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/astravalabs~etsy-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-astravalabs-etsy-listings-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/astravalabs~etsy-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-astravalabs-etsy-listings-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/astravalabs~etsy-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-astravalabs-etsy-listings-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "List of search keywords to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Max pages per keyword",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of Etsy search result pages to scrape per keyword. The first page is smaller; later pages yield ~64 listings each.",
                        "default": 5
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "IE",
                            "BE",
                            "AT",
                            "PT",
                            "SE",
                            "NO",
                            "DK",
                            "PL",
                            "CH",
                            "CZ",
                            "HU",
                            "RO",
                            "BG",
                            "HR",
                            "JP",
                            "SG",
                            "HK",
                            "IN",
                            "IL",
                            "ZA",
                            "BR",
                            "MX"
                        ],
                        "type": "string",
                        "description": "ISO-3166 country code for localized search results and currency.",
                        "default": "US"
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Filter listings to this minimum price (in the selected country's currency)."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Filter listings to this maximum price (in the selected country's currency)."
                    },
                    "maxResults": {
                        "title": "Max results per keyword",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop collecting listings for a keyword once this many are gathered. Leave empty for no cap."
                    },
                    "maxTotalResults": {
                        "title": "Max total results per run",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop the entire run after this many listings have been saved across all keywords. Leave empty for no run-wide cap."
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "most_relevant",
                            "price_asc",
                            "price_desc",
                            "highest_reviews",
                            "date_desc"
                        ],
                        "type": "string",
                        "description": "How to sort the search results.",
                        "default": "most_relevant"
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "all",
                            "digital",
                            "physical"
                        ],
                        "type": "string",
                        "description": "Filter by listing type.",
                        "default": "all"
                    },
                    "onSale": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Return only discounted / sale listings.",
                        "default": false
                    },
                    "freeShipping": {
                        "title": "Free shipping only",
                        "type": "boolean",
                        "description": "Return only listings that offer free shipping.",
                        "default": false
                    },
                    "starSeller": {
                        "title": "Star sellers only",
                        "type": "boolean",
                        "description": "Return only listings from Star Seller shops.",
                        "default": false
                    },
                    "customizable": {
                        "title": "Customizable only",
                        "type": "boolean",
                        "description": "Return only listings that accept customization.",
                        "default": false
                    },
                    "etsyPick": {
                        "title": "Etsy's pick only",
                        "type": "boolean",
                        "description": "Return only listings curated by Etsy (merch library).",
                        "default": false
                    },
                    "excludeSponsored": {
                        "title": "Exclude sponsored listings",
                        "type": "boolean",
                        "description": "Strip ad/sponsored listings from results. Sponsored listings are still fetched but not saved.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
