# Daangn Scraper $1💰 Listings, Sellers, Regions & Categories (`abotapi/daangn-scraper`) Actor

From $1/1K. Scrape Daangn (당근) marketplace listings by keyword and region. Returns 35+ fields per item including price, status, condition, full image set, region, category and seller profile (nickname, score, reviews). Search and URL modes, category and on-sale filters, price range and sort.

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

## Pricing

from $1.00 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Daangn Scraper

Collect structured listing data from Daangn (당근), Korea's largest local marketplace, by keyword and region. The scraper returns rich, ready-to-use records: price, status, condition, the full image set, region, category and the seller profile (nickname, score, review count). Run it by keyword, by region, or by pasting Daangn search and detail URLs, and pipe the results straight into your spreadsheet, database or apps.

### Why This Scraper?

- 35+ fields per listing, including the full image set, region tree, category and the complete seller profile, not just a title and a price.
- Two ways to run: search by keyword + region, or paste any Daangn search or detail URL.
- Server-side category and on-sale filters plus price-range and sort controls.
- One simple limit: set Max items and the run stops there. No confusing second cap.
- Optional detail enrichment adds description, view/chat/favorite counts and the seller profile per item.
- Optional one-click export into Notion, Linear, Airtable or Apify via MCP connectors.
- Runs on the default datacenter proxy on every plan; switch to Residential (country KR) for the most reliable results.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live listing.

| Field | Example |
| --- | --- |
| id | "0000000000" |
| nodeId | "a0b0c0d0e0f0" |
| url | "https://www.daangn.com/kr/buy-sell/sample-a0b0c0d0e0f0/" |
| title | "iPhone 15 256GB Blue" |
| price | 480000 |
| priceText | "480,000원" |
| isFree | false |
| currency | "KRW" |
| status | "Ongoing" |
| condition | "used" |
| content | "Lightly used, battery health 90%." |
| location | "Sample-dong" |
| region.name | "Sample-dong" |
| region.id | "000" |
| category.name | "Digital" |
| category.id | "1" |
| sellerName | "Jane Doe" |
| user.score | 39.2 |
| user.reviewCount | 23 |
| watchesCount | 12 |
| chatRoomsCount | 6 |
| readsCount | 733 |
| createdAt | "2026-01-01T00:00:00.000+09:00" |
| imageUrl | "https://img.example.com/sample_0.webp" |

### How to Use

Search by keyword in one region:

```json
{
  "mode": "search",
  "searchQueries": ["아이폰"],
  "locations": ["366"],
  "maxItems": 50,
  "fetchDetails": true
}
````

Search several keywords across several regions with a price range:

```json
{
  "mode": "search",
  "searchQueries": ["노트북", "의자"],
  "locations": ["366", "6187"],
  "priceMin": 50000,
  "priceMax": 300000,
  "sortBy": "price_asc",
  "maxItems": 100
}
```

Paste Daangn URLs directly:

```json
{
  "mode": "url",
  "urls": [
    "https://www.daangn.com/kr/buy-sell/s/?search=%EC%95%84%EC%9D%B4%ED%8F%B0&region_id=366",
    "https://www.daangn.com/kr/buy-sell/sample-a0b0c0d0e0f0/"
  ],
  "fetchDetails": true,
  "maxItems": 40
}
```

### Input Parameters

| Field | Type | Description |
| --- | --- | --- |
| mode | string | "search" builds searches from your keywords + regions + filters; "url" uses pasted Daangn URLs. |
| searchQueries | array | Keywords to search for (search mode). Each is scraped independently. |
| locations | array | Numeric Daangn region ids to center the search on. Empty = region resolved from the connection. |
| categoryId | integer | Restrict to one Daangn category id (e.g. 1 Digital, 8 Furniture). Empty = all. |
| onlyOnSale | boolean | Return only listings still on sale (excludes reserved/completed). |
| priceMin | integer | Only listings priced at or above this amount (KRW). |
| priceMax | integer | Only listings priced at or below this amount (KRW). |
| sortBy | string | "recommended", "recent", "price\_asc" or "price\_desc". |
| urls | array | Daangn search or detail URLs (URL mode). Filter fields are ignored. |
| fetchDetails | boolean | Visit each listing page for description, image set, counts and seller profile. |
| maxItems | integer | The single run cap. Stop after this many listings. 0 = unlimited. |
| maxPages | integer | Safety bound on result pages per query. Empty = unlimited; the run stops at Max items. |
| proxy | object | Connection settings. Datacenter is the default and works on every plan; Residential (country KR) is the most reliable. |
| maxResidentialMB | integer | Residential traffic budget in MB. After the cap the run continues on the lower-cost datacenter proxy (same data). 0 = unlimited. |
| mcpConnectors | array | Optional MCP connectors to export results into (Notion, Linear, Airtable, Apify). |
| notionParentPageUrl | string | Notion page under which item pages are created (Notion connector only). |
| maxNotifyListings | integer | Cap on items written to each connector per run. Does not affect the dataset. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live listing.

```json
{
  "id": "0000000000",
  "nodeId": "a0b0c0d0e0f0",
  "url": "https://www.daangn.com/kr/buy-sell/sample-a0b0c0d0e0f0/",
  "title": "iPhone 15 256GB Blue",
  "content": "Lightly used, battery health 90%.",
  "description": "Lightly used, battery health 90%.",
  "status": "Ongoing",
  "condition": "used",
  "listingType": "FleamarketArticle",
  "price": 480000,
  "priceText": "480,000원",
  "isFree": false,
  "currency": "KRW",
  "countryCode": "KR",
  "createdAt": "2026-01-01T00:00:00.000+09:00",
  "postedAt": "2026-01-01T00:00:00.000+09:00",
  "publishedAt": "2026-01-01T00:00:00.000+09:00",
  "imageUrl": "https://img.example.com/sample_0.webp",
  "images": ["https://img.example.com/sample_0.webp"],
  "location": "Sample-dong",
  "locationName": null,
  "regionSlug": "sample-dong-000",
  "searchQuery": "아이폰",
  "region": { "id": "000", "name": "Sample-dong", "countryCode": "KR" },
  "category": { "id": "1", "name": "Digital" },
  "user": { "nickname": "Jane Doe", "score": 39.2, "reviewCount": 23, "locationName": null },
  "tradingLocation": { "name": "Sample-dong", "isUserInput": null, "latitude": null, "longitude": null },
  "sellerName": "Jane Doe",
  "watchesCount": 12,
  "chatRoomsCount": 6,
  "readsCount": 733
}
```

#### Export to your apps (MCP connectors)

You can optionally pipe each run's results into the apps you already use through Model Context Protocol (MCP) connectors. Authorize a connector under Apify -> Settings -> API & Integrations, then select it in the mcpConnectors field. Notion receives a rich page per item (set notionParentPageUrl to the parent page); Linear, Airtable and Apify receive a best-effort write or digest. This never changes the dataset output, and any connector error is logged and skipped without affecting the scrape.

### Plan Requirement

This scraper runs on the default datacenter proxy on any plan, including the free tier, and returns the same Daangn data as residential, so it is the recommended default.

For maximum reliability you can switch the proxy to Apify Residential with country KR (requires a plan that includes Residential proxy access). When on residential, set a **Residential traffic budget (MB)** to cap spend: once the budget is reached the run continues on the default datacenter proxy for the rest of the run, with identical results.

# Actor input Schema

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

How to start the scrape. 'search' builds Daangn searches from your keywords + regions + filters. 'url' uses the Daangn search or detail URLs you paste (filter fields below are ignored in URL mode).

## `searchQueries` (type: `array`):

One or more keywords to search Daangn for. Each query is scraped independently.

## `locations` (type: `array`):

Numeric Daangn region ids to center the search on (e.g. '366' for Seocho-4-dong, '6187' for Sincheon-dong). Each query is run for each region. Leave empty to use the region resolved from the connection automatically.

## `categoryId` (type: `integer`):

Restrict results to one Daangn category id. Examples: 1 Digital, 172 Appliances, 8 Furniture, 7 Living/Kitchen, 4 Baby/Kids, 5 Women's clothing, 14 Men's fashion, 6 Beauty, 3 Sports/Leisure, 2 Hobby/Game, 9 Books, 13 Other. Leave empty for all categories.

## `onlyOnSale` (type: `boolean`):

Return only listings that are still on sale (excludes reserved and completed items).

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

Only return listings priced at or above this amount.

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

Only return listings priced at or below this amount.

## `sortBy` (type: `string`):

Order results are returned in.

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

Paste Daangn search URLs (https://www.daangn.com/kr/buy-sell/s/?search=...) or item detail URLs (https://www.daangn.com/kr/buy-sell/<slug>-<id>/). Multi-URL supported; filter-mode fields are ignored.

## `fetchDetails` (type: `boolean`):

Adds the description, full image set, category, view/chat/favorite counts and the complete seller profile (score, reviews, profile image) to each listing. Slower; turn off for fast basic listings.

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

THE cap on this run: stop after collecting this many listings (across all queries/URLs). This is the only finite default cap. Set 0 for unlimited.

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

Optional safety bound on how many result pages to walk per query. Defaults to unlimited (leave empty or 0) and does NOT cap the run: the run stops at Max items, never here. Use only to short-circuit a single query's pagination; it never imposes a separate cap and always defers to Max items.

## `proxy` (type: `object`):

Connection used for requests. Datacenter (the default) is the cheapest and works on every plan; Residential with country KR is the most reliable.

## `maxResidentialMB` (type: `integer`):

When using a Residential proxy group, cap residential traffic at this many MB; after the cap the run continues on the lower-cost datacenter proxy, which returns the same Daangn data. 0 = unlimited.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify -> Settings -> API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write/digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "아이폰"
  ],
  "locations": [
    "366"
  ],
  "onlyOnSale": false,
  "sortBy": "recommended",
  "urls": [
    "https://www.daangn.com/kr/buy-sell/s/?search=%EC%95%84%EC%9D%B4%ED%8F%B0"
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "maxResidentialMB": 0,
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "아이폰"
    ],
    "locations": [
        "366"
    ],
    "urls": [
        "https://www.daangn.com/kr/buy-sell/s/?search=%EC%95%84%EC%9D%B4%ED%8F%B0"
    ],
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/daangn-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 = {
    "searchQueries": ["아이폰"],
    "locations": ["366"],
    "urls": ["https://www.daangn.com/kr/buy-sell/s/?search=%EC%95%84%EC%9D%B4%ED%8F%B0"],
    "maxItems": 20,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/daangn-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 '{
  "searchQueries": [
    "아이폰"
  ],
  "locations": [
    "366"
  ],
  "urls": [
    "https://www.daangn.com/kr/buy-sell/s/?search=%EC%95%84%EC%9D%B4%ED%8F%B0"
  ],
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/daangn-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Daangn Scraper $1💰 Listings, Sellers, Regions & Categories",
        "description": "From $1/1K. Scrape Daangn (당근) marketplace listings by keyword and region. Returns 35+ fields per item including price, status, condition, full image set, region, category and seller profile (nickname, score, reviews). Search and URL modes, category and on-sale filters, price range and sort.",
        "version": "1.0",
        "x-build-id": "Wgwduaj0K8XogzgXx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/abotapi~daangn-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-abotapi-daangn-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/abotapi~daangn-scraper/runs": {
            "post": {
                "operationId": "runs-sync-abotapi-daangn-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/abotapi~daangn-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-abotapi-daangn-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": [
                            "search",
                            "url"
                        ],
                        "type": "string",
                        "description": "How to start the scrape. 'search' builds Daangn searches from your keywords + regions + filters. 'url' uses the Daangn search or detail URLs you paste (filter fields below are ignored in URL mode).",
                        "default": "search"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more keywords to search Daangn for. Each query is scraped independently.",
                        "default": [
                            "아이폰"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Regions (region ids)",
                        "type": "array",
                        "description": "Numeric Daangn region ids to center the search on (e.g. '366' for Seocho-4-dong, '6187' for Sincheon-dong). Each query is run for each region. Leave empty to use the region resolved from the connection automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryId": {
                        "title": "Category id",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Restrict results to one Daangn category id. Examples: 1 Digital, 172 Appliances, 8 Furniture, 7 Living/Kitchen, 4 Baby/Kids, 5 Women's clothing, 14 Men's fashion, 6 Beauty, 3 Sports/Leisure, 2 Hobby/Game, 9 Books, 13 Other. Leave empty for all categories."
                    },
                    "onlyOnSale": {
                        "title": "Only items on sale",
                        "type": "boolean",
                        "description": "Return only listings that are still on sale (excludes reserved and completed items).",
                        "default": false
                    },
                    "priceMin": {
                        "title": "Minimum price (KRW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or above this amount."
                    },
                    "priceMax": {
                        "title": "Maximum price (KRW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return listings priced at or below this amount."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "recommended",
                            "recent",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "Order results are returned in.",
                        "default": "recommended"
                    },
                    "urls": {
                        "title": "Daangn URLs",
                        "type": "array",
                        "description": "Paste Daangn search URLs (https://www.daangn.com/kr/buy-sell/s/?search=...) or item detail URLs (https://www.daangn.com/kr/buy-sell/<slug>-<id>/). Multi-URL supported; filter-mode fields are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch full details",
                        "type": "boolean",
                        "description": "Adds the description, full image set, category, view/chat/favorite counts and the complete seller profile (score, reviews, profile image) to each listing. Slower; turn off for fast basic listings.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "THE cap on this run: stop after collecting this many listings (across all queries/URLs). This is the only finite default cap. Set 0 for unlimited.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Max pages per query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional safety bound on how many result pages to walk per query. Defaults to unlimited (leave empty or 0) and does NOT cap the run: the run stops at Max items, never here. Use only to short-circuit a single query's pagination; it never imposes a separate cap and always defers to Max items."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Connection used for requests. Datacenter (the default) is the cheapest and works on every plan; Residential with country KR is the most reliable.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxResidentialMB": {
                        "title": "Residential traffic budget (MB)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "When using a Residential proxy group, cap residential traffic at this many MB; after the cap the run continues on the lower-cost datacenter proxy, which returns the same Daangn data. 0 = unlimited.",
                        "default": 0
                    },
                    "mcpConnectors": {
                        "title": "Pipe results into your apps (optional)",
                        "type": "array",
                        "description": "Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify -> Settings -> API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write/digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com)."
                    },
                    "notionParentPageUrl": {
                        "title": "Notion parent page (Notion connector only)",
                        "type": "string",
                        "description": "URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors."
                    },
                    "maxNotifyListings": {
                        "title": "Max items to export per connector",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on items written to each connector per run. Does not affect the dataset.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
