# Karrot Listings Extractor (`kawsar/karrot-listings-extractor`) Actor

Karrot marketplace scraper that pulls secondhand listings with prices, photos, seller profiles, and view counts from any keyword or neighborhood search, so you can research prices, source resale deals, and track local demand without an API.

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

## Pricing

from $2.99 / 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.
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

## Karrot Listings Extractor

Karrot Listings Extractor is a Karrot marketplace scraper that pulls secondhand listings from [karrotmarket.com](https://www.karrotmarket.com) search results. Give it a keyword and a locality (or paste a search URL straight from your browser) and it returns structured data for every listing it finds: title, price, photos, seller profile, category, coordinates, and engagement numbers like views and watch counts.

Karrot (known as Danggeun in Korea) is one of the largest local buy-and-sell apps in North America, but it has no public API. This actor fills that gap. It handles pagination on its own and uses built-in bypass infrastructure, so there is nothing to configure.

### Use cases

- **Price research**: see what used Samsung TVs actually sell for in Manhattan before you list yours
- **Reseller sourcing**: monitor searches for underpriced items in your area and get to them first
- **Market analysis**: track supply, pricing, and demand signals (views, watchers, chats) for a product category over time
- **Lead generation**: find active sellers of specific goods in a target region
- **Dataset building**: collect labeled product photos and descriptions for machine learning projects

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `Samsung` | Keyword to search for on Karrot |
| `locality` | string | `Manhattan` | Neighborhood or city to search in |
| `startUrls` | array | - | Full Karrot buy-sell URLs copied from your browser, one per line. Use instead of (or alongside) the keyword |
| `includeDetails` | boolean | `true` | Open each listing page for all photos, the full description, seller profile, and stats |
| `maxItems` | integer | `50` | Maximum listings to save per run (up to 1000) |
| `requestTimeoutSecs` | integer | `30` | Per-request timeout in seconds |

You need either a `searchQuery` or at least one entry in `startUrls`. Everything else is optional.

#### Example input

```json
{
    "searchQuery": "Samsung",
    "locality": "Manhattan",
    "includeDetails": true,
    "maxItems": 50
}
````

Or with a URL copied from the Karrot website, including its location filters:

```json
{
    "startUrls": [
        "https://www.karrotmarket.com/buy-sell/all/?locality=Manhattan&search=Samsung"
    ],
    "maxItems": 100
}
```

### Output

Each listing becomes one dataset item:

```json
{
    "listingId": 10214605,
    "nodeId": "ng5cmzr8xmyi",
    "listingUrl": "https://www.karrotmarket.com/buy-sell/ng5cmzr8xmyi/",
    "listingTitle": "Samsung TV",
    "price": "55",
    "priceDescription": "$55",
    "listingType": "sell",
    "listingStatus": "ongoing",
    "thumbnailUrl": "https://img.ca.gcp-karroter.net/origin/article/202606/1782257711672bd14c2bdf5ad9b610f7ed1572a8fed050a662d7befd040312181323e93acdfbb0.webp",
    "imageUrls": [
        "https://img.ca.gcp-karroter.net/origin/article/202606/1782257711672bd14c2bdf5ad9b610f7ed1572a8fed050a662d7befd040312181323e93acdfbb0.webp",
        "https://img.ca.gcp-karroter.net/origin/article/202606/1782257711685bd14c2bdf5ad9b610f7ed1572a8fed050a662d7befd040312181323e93acdfbb0.webp"
    ],
    "imagesCount": 5,
    "listingDescription": "Samsung TV in black. Screen is 40 inches. Works great!",
    "categoryName": "Electronics & Appliances",
    "locationName": "Concourse Village",
    "distanceFromSearchArea": "4mi",
    "regionName": "Concourse",
    "latitude": 40.823037,
    "longitude": -73.922148,
    "countryCode": "US",
    "sellerId": "7684419",
    "sellerName": "Ingrid",
    "sellerScore": 10,
    "sellerReviewCount": 0,
    "sellerVerified": false,
    "createdAt": "2026-06-23T23:40:23Z",
    "publishedAt": "2026-07-06T16:34:43Z",
    "republishCount": 4,
    "watchesCount": 3,
    "chatRoomsCount": 5,
    "readsCount": 157,
    "sourceUrl": "https://www.karrotmarket.com/buy-sell/all/?search=Samsung&locality=Manhattan",
    "scrapedAt": "2026-07-07T12:00:00+00:00",
    "error": null
}
```

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | integer | Numeric Karrot listing ID |
| `nodeId` | string | Short public ID used in the listing URL |
| `listingUrl` | string | Direct link to the listing |
| `listingTitle` | string | Listing headline |
| `price` | string | Asking price as a plain number |
| `priceDescription` | string | Formatted price, e.g. `$55` |
| `listingStatus` | string | `ongoing`, `reserved`, or `closed` |
| `thumbnailUrl` | string | Main photo |
| `imageUrls` | array | All photos in full resolution (with details on) |
| `listingDescription` | string | Full seller-written description (with details on) |
| `categoryName` | string | Karrot category |
| `locationName` | string | Neighborhood shown on the card |
| `latitude` / `longitude` | number | Trading location coordinates (with details on) |
| `sellerName` | string | Seller nickname (with details on) |
| `sellerScore` | number | Seller reputation score (with details on) |
| `watchesCount` | integer | Users watching the listing (with details on) |
| `chatRoomsCount` | integer | Chats started about the listing (with details on) |
| `readsCount` | integer | Listing views (with details on) |
| `scrapedAt` | string | Extraction timestamp, ISO 8601 UTC |

Fields marked "with details on" are filled when `includeDetails` is enabled. With it off, you still get the core listing card data (title, price, status, thumbnail, location) and runs finish much faster.

### How it works

1. Resolves your locality name to map coordinates and builds the same search URL the Karrot site uses, so results always come from the area you asked for. URLs you paste are used as-is
2. Loads the search results and walks through result pages until it reaches your `maxItems` limit or runs out of listings
3. With `includeDetails` on, opens each listing page to collect photos, the full description, seller info, and engagement stats
4. Deduplicates listings across pages and saves each one to the dataset

A run with details enabled makes one request per listing plus one per results page, so 50 listings means roughly 52 page loads. Turn `includeDetails` off when you only need prices and titles at scale.

### Tips

- Listings are local by nature. The same search in Brooklyn and Manhattan returns different results, so run one search per area you care about.
- `readsCount`, `watchesCount`, and `chatRoomsCount` are decent demand signals. High views with an `ongoing` status often means the item is overpriced.
- Prices come back as strings because sellers sometimes list at 0 (free items) or leave the price open.

### Integrations

Connect Karrot Listings Extractor with other apps and services using [Apify integrations](https://apify.com/integrations). You can integrate with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and many more. You can also use [webhooks](https://docs.apify.com/integrations/webhooks) to trigger actions whenever results are available.

# Actor input Schema

## `searchQuery` (type: `string`):

What to search for on Karrot, for example 'Samsung', 'iPhone 14', or 'road bike'. Leave empty if you provide start URLs instead.

## `locality` (type: `string`):

Neighborhood or city to search in, for example 'Manhattan', 'Brooklyn', or 'Toronto'. Used together with the search keyword.

## `startUrls` (type: `array`):

Full Karrot buy-sell URLs copied from your browser, one per line. Use this for exact searches with location filters, for example https://www.karrotmarket.com/buy-sell/all/?locality=Manhattan\&search=Samsung

## `includeDetails` (type: `boolean`):

Open every listing page to collect all photos, the full item description, seller profile, category, coordinates, and view/watch/chat counts. Slower but much richer output.

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

Maximum number of listings to save per run.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchQuery": "Samsung",
  "locality": "Manhattan",
  "startUrls": [
    "https://www.karrotmarket.com/buy-sell/all/?locality=Manhattan&search=Samsung"
  ],
  "includeDetails": false,
  "maxItems": 20,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "searchQuery": "Samsung",
    "locality": "Manhattan"
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/karrot-listings-extractor").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 = {
    "searchQuery": "Samsung",
    "locality": "Manhattan",
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/karrot-listings-extractor").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 '{
  "searchQuery": "Samsung",
  "locality": "Manhattan"
}' |
apify call kawsar/karrot-listings-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Karrot Listings Extractor",
        "description": "Karrot marketplace scraper that pulls secondhand listings with prices, photos, seller profiles, and view counts from any keyword or neighborhood search, so you can research prices, source resale deals, and track local demand without an API.",
        "version": "0.0",
        "x-build-id": "cwBCHCr9fK6k7SsBK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~karrot-listings-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-karrot-listings-extractor",
                "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/kawsar~karrot-listings-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-karrot-listings-extractor",
                "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/kawsar~karrot-listings-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-karrot-listings-extractor",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "What to search for on Karrot, for example 'Samsung', 'iPhone 14', or 'road bike'. Leave empty if you provide start URLs instead."
                    },
                    "locality": {
                        "title": "Locality",
                        "type": "string",
                        "description": "Neighborhood or city to search in, for example 'Manhattan', 'Brooklyn', or 'Toronto'. Used together with the search keyword."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Full Karrot buy-sell URLs copied from your browser, one per line. Use this for exact searches with location filters, for example https://www.karrotmarket.com/buy-sell/all/?locality=Manhattan&search=Samsung",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Include full listing details",
                        "type": "boolean",
                        "description": "Open every listing page to collect all photos, the full item description, seller profile, category, coordinates, and view/watch/chat counts. Slower but much richer output.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to save per run.",
                        "default": 20
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
