# Sellpy Product Search Scraper (`stealth_mode/sellpy-product-search-scraper`) Actor

Scrape Sellpy.se product listings with 51+ data fields per item. Capture pricing, inventory status, brand info, images, customer favorites, and ranking metrics — perfect for market analysis, price monitoring, and resale business intelligence.

- **URL**: https://apify.com/stealth\_mode/sellpy-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 1 total users, 1 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Sellpy Product Search Scraper: Extract Secondhand Fashion Data at Scale

---

### What Is Sellpy?

Sellpy is a leading European secondhand fashion marketplace operating primarily in Sweden (.se), Germany (.de), and neighboring Nordic countries. It connects millions of buyers and sellers of pre-owned clothing, shoes, and accessories. With thousands of active listings updated daily, Sellpy represents a valuable dataset for understanding fashion trends, pricing dynamics, and consumer demand in the circular economy. The **Sellpy Product Search Scraper** automates extraction of this marketplace data into structured, analyzable records.

---

### Overview

The **Sellpy Product Search Scraper** extracts detailed product information from Sellpy's search results, transforming marketplace pages into structured datasets. It is designed for:

- **Fashion analysts** tracking trends and price movements in secondhand markets
- **Marketplace researchers** benchmarking inventory and pricing strategies
- **Fashion retailers** monitoring competitor listings and consumer demand
- **Data scientists** building models on circular fashion consumption patterns
- **Price aggregators** feeding Sellpy data into comparison tools

The scraper handles pagination, respects marketplace structure, and returns 50+ fields per product including pricing data, images, brand classification, and marketplace-specific metadata.

---

### Input Format

The scraper accepts a JSON configuration object for flexible search-based extraction:

```json
{
  "urls": [
    "https://www.sellpy.se/search/Kvinna/Kläder/Klänningar?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Field | Type | Description |
|---|---|---|
| `urls` | array | Direct links to Sellpy search results pages. Can include filter parameters (category, size, price range, page number). Supports .se, .de, and other regional Sellpy domains. |
| `max_items_per_url` | integer | Maximum products to extract per search URL (e.g., `200`). Useful for controlling dataset size or testing. Default: `20`. |
| `ignore_url_failures` | boolean | If `true`, scraper continues if a URL fails. If `false`, the entire run stops on first error. Recommended: `true` for bulk operations. |

> **Tip:** Use category-filtered URLs (e.g., `Women/Clothes/Dresses`) to target specific product segments. Pagination parameters are supported—add `?page=1`, `?page=2`, etc. to URLs.

***

### Output Format

**Sample output**

```json
{
  "created_at": 1777544948,
  "updated_at": 1782532817,
  "user": "Z9EgUawPFj",
  "bag": "D2lXAtZ1Nz",
  "metadata": {
    "size": "SHOES-EU-45",
    "season": [
      "Spring",
      "Summer",
      "Fall"
    ],
    "color": [
      "Red",
      "Black"
    ],
    "brand": "Asics",
    "model": "T516N",
    "demography": "Men",
    "country_of_origin": "VN",
    "type": "Running shoes",
    "condition": "Very good",
    "product_code": "F451015 PV"
  },
  "images": [
    "https://prod.images.sellpy.net/photoRobot-case-14-k-10/J76Y3hZiKu-fd92-0.jpg",
    "https://prod.images.sellpy.net/photoRobot-case-14-k-10/J76Y3hZiKu-fd92-90.jpg",
    "https://prod.images.sellpy.net/photoRobot-case-14-k-10/J76Y3hZiKu-fd92-270.jpg",
    "https://prod.images.sellpy.net/phone-images/J76Y3hZiKu-91ee.jpg",
    "https://prod.images.sellpy.net/phone-images/J76Y3hZiKu-994c.jpg"
  ],
  "sizes": [
    "SHOES-EU-45"
  ],
  "p2p": false,
  "is_reserved": false,
  "segment": "men",
  "item_io": "rLRCT4wPCb",
  "categories": {
    "lvl0": [
      "Men"
    ],
    "lvl1": [
      "Men > Shoes"
    ],
    "lvl2": [
      "Men > Shoes > Sport shoes"
    ]
  },
  "storage_site": "K",
  "is_on_shelf": true,
  "searchable_external_category": [
    "Men > Shoes > Sport shoes"
  ],
  "sale_type": "regular",
  "personalization_size_category": "SHOES-EU-45-Men > Shoes > Sport shoes",
  "title_output_order": [
    "brand",
    "type",
    "size"
  ],
  "body_output_order": [
    "brand",
    "type",
    "size",
    "sizeEstimated",
    "model",
    "material",
    "color",
    "demography",
    "extra"
  ],
  "item_ab_test_fraction": 0.2893018385419257,
  "brand_classification": {
    "styles": [
      "Performance",
      "Athleisure"
    ],
    "age_groups": [
      "Gen Y",
      "Gen X"
    ],
    "price_point": 4,
    "origin_vibe": "Japanese",
    "ethos": "Tech / Performance",
    "aesthetic_tone": "Functional"
  },
  "materials": null,
  "keywords": [
    "athletic shoes",
    "red sneakers",
    "performance footwear",
    "cushioned sole",
    "sports shoes",
    "outdoor footwear"
  ],
  "style": [
    "athleisure"
  ],
  "brand_groups": [
    "Athletic & Sportswear",
    "Footwear & Socks"
  ],
  "concept": [
    "Runner's High",
    "Athletic Wear & Training Shoes",
    "Activewear & Sportswear",
    "The Marathon Shop"
  ],
  "weight": 0.6,
  "item_packaging": "FGxNnLyDDp",
  "favourite_count": 3,
  "favorite_count_bucket": 2,
  "favorite_count_bucket_nordic": 1,
  "favorite_count_bucket_dach": 1,
  "favorite_count_bucket_eu": 0,
  "relevance_ranking_normal_dist_15_similar_item": null,
  "relevance_ranking_normal_dist_15": null,
  "proximity_bucket_v1": 1,
  "proximity_bucket_v2": 3,
  "sales_channel": "market",
  "pricing": {
    "amount": 2500,
    "currency": "CZK"
  },
  "is_for_sale": true,
  "sale_started_at": 1781798688003,
  "last_chance": false,
  "price_se": {
    "amount": 109000,
    "currency": "SEK"
  },
  "price_drop_se": {
    "show_until": 1781885087698,
    "old_price": {
      "amount": 115500,
      "currency": "SEK"
    }
  },
  "first_offered_at_se": 1777908755473,
  "featured_in": [
    "21651652-591f-4358-a153-371c95e78077",
    "8441a027-e90d-4fb0-9cb1-9fb409e7966d",
    "3ba91ead-f978-48b2-b68e-d33ca207c994",
    "83a97683-5d60-468c-9556-b8e3363ccc76",
    "52786708-e94c-4470-b9ed-013c291cad09",
    "dee4c350-8b91-493c-8f1c-f5d3097d1b75",
    "23336ec7-b11a-4ea3-906e-1cdc30e7a7df",
    "415c8534-b905-4f2e-bdd5-7b46f92b87df",
    "3d486eb4-9362-42b3-90ca-78f15d0c7bcf",
    "c0d3d298-1cf0-4cd2-aef4-3bc159c1110c",
    "91b2fa12-28bc-4d19-ba19-e4c29ac44821",
    "de981fa2-ff62-46d0-8578-69c95a863ef3",
    "fe5087f4-d5d1-4ce4-a559-8887190d57f7",
    "ae65e87a-ff29-4e1b-889c-17a6f997dec8",
    "c023de45-cc45-445e-a654-ecb1880b91bf",
    "2efcf323-d911-4a27-9f5f-cdaa25bce22a",
    "11a39d3b-0181-42cb-a8d6-6472cfd51da0",
    "d2e4d407-e6a1-45f8-ad76-baae8cbc87cd",
    "0ee2fe4e-5887-4b35-83a9-a801865968fd",
    "dd8c6a4a-5946-4659-bd88-eadb52a70c24",
    "3109642a-a12f-424a-b9e2-aa2ab68a7b1f",
    "80a8757f-4de5-4f91-a9e3-dec553912dec"
  ],
  "object_id": "fMmJQ6Ww5C",
  "highlight_result": {
    "user": {
      "value": "Z9EgUawPFj",
      "match_level": "none",
      "matched_words": []
    },
    "metadata": {
      "size": {
        "value": "__ais-highlight__SHOE__/ais-highlight__S-EU-45",
        "match_level": "full",
        "fully_highlighted": false,
        "matched_words": [
          "shoe"
        ]
      },
      "season": [
        {
          "value": "Spring",
          "match_level": "none",
          "matched_words": []
        },
        {
          "value": "Summer",
          "match_level": "none",
          "matched_words": []
        },
        {
          "value": "Fall",
          "match_level": "none",
          "matched_words": []
        }
      ],
      "color": [
        {
          "value": "Red",
          "match_level": "none",
          "matched_words": []
        },
        {
          "value": "Black",
          "match_level": "none",
          "matched_words": []
        }
      ],
      "brand": {
        "value": "Asics",
        "match_level": "none",
        "matched_words": []
      },
      "model": {
        "value": "T516N",
        "match_level": "none",
        "matched_words": []
      },
      "demography": {
        "value": "Men",
        "match_level": "none",
        "matched_words": []
      },
      "type": {
        "value": "Running __ais-highlight__shoe__/ais-highlight__s",
        "match_level": "full",
        "fully_highlighted": false,
        "matched_words": [
          "shoe"
        ]
      }
    },
    "sizes": [
      {
        "value": "__ais-highlight__SHOE__/ais-highlight__S-EU-45",
        "match_level": "full",
        "fully_highlighted": false,
        "matched_words": [
          "shoe"
        ]
      }
    ],
    "keywords": [
      {
        "value": "athletic __ais-highlight__shoe__/ais-highlight__s",
        "match_level": "full",
        "fully_highlighted": false,
        "matched_words": [
          "shoe"
        ]
      },
      {
        "value": "red sneakers",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "performance footwear",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "cushioned sole",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "sports __ais-highlight__shoe__/ais-highlight__s",
        "match_level": "full",
        "fully_highlighted": false,
        "matched_words": [
          "shoe"
        ]
      },
      {
        "value": "outdoor footwear",
        "match_level": "none",
        "matched_words": []
      }
    ],
    "style": [
      {
        "value": "athleisure",
        "match_level": "none",
        "matched_words": []
      }
    ],
    "featured_in": [
      {
        "value": "21651652-591f-4358-a153-371c95e78077",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "8441a027-e90d-4fb0-9cb1-9fb409e7966d",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "3ba91ead-f978-48b2-b68e-d33ca207c994",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "83a97683-5d60-468c-9556-b8e3363ccc76",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "52786708-e94c-4470-b9ed-013c291cad09",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "dee4c350-8b91-493c-8f1c-f5d3097d1b75",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "23336ec7-b11a-4ea3-906e-1cdc30e7a7df",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "415c8534-b905-4f2e-bdd5-7b46f92b87df",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "3d486eb4-9362-42b3-90ca-78f15d0c7bcf",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "c0d3d298-1cf0-4cd2-aef4-3bc159c1110c",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "91b2fa12-28bc-4d19-ba19-e4c29ac44821",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "de981fa2-ff62-46d0-8578-69c95a863ef3",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "fe5087f4-d5d1-4ce4-a559-8887190d57f7",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "ae65e87a-ff29-4e1b-889c-17a6f997dec8",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "c023de45-cc45-445e-a654-ecb1880b91bf",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "2efcf323-d911-4a27-9f5f-cdaa25bce22a",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "11a39d3b-0181-42cb-a8d6-6472cfd51da0",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "d2e4d407-e6a1-45f8-ad76-baae8cbc87cd",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "0ee2fe4e-5887-4b35-83a9-a801865968fd",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "dd8c6a4a-5946-4659-bd88-eadb52a70c24",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "3109642a-a12f-424a-b9e2-aa2ab68a7b1f",
        "match_level": "none",
        "matched_words": []
      },
      {
        "value": "80a8757f-4de5-4f91-a9e3-dec553912dec",
        "match_level": "none",
        "matched_words": []
      }
    ]
  },
  "ranking_info": {
    "forced_typo_first_in_ranking": true,
    "nb_typos": 0,
    "first_matched_word": 0,
    "proximity_distance": 0,
    "user_score": 900,
    "geo_distance": 0,
    "geo_precision": 1,
    "nb_exact_words": 0,
    "words": 1,
    "filters": 1
  },
  "from_url": "https://www.sellpy.com/search?page=2&query=shoe"
}
```

Each scraped product returns a comprehensive record with 50+ fields covering product details, marketplace metadata, and pricing:

#### Product Identification & Metadata

| Field | Meaning |
|---|---|
| `Object ID` | Unique product identifier in Sellpy's system |
| `Title Output Order` | Product name/title as displayed |
| `Body Output Order` | Product description text |
| `Images` | Array of product image URLs (multiple angles) |
| `Created At` | When the listing was first created |
| `Updated At` | Last modification timestamp |
| `User` | Seller/owner information |

#### Classification & Attributes

| Field | Meaning |
|---|---|
| `Categories` | Product category hierarchy (e.g., Women > Clothes > Dresses) |
| `Brand Classification` | Detected or assigned brand name |
| `Brand Groups` | Brand grouping for analytics (luxury, fast-fashion, etc.) |
| `Materials` | Fabric composition (e.g., cotton, polyester, silk) |
| `Style` | Style classification (casual, formal, sports, etc.) |
| `Sizes` | Available sizes or size category |
| `Personalization Size Category` | Standardized size mapping for cross-market comparison |
| `Concept` | Product concept or sub-category |
| `Keywords` | Search keywords associated with the product |
| `Segment` | Market segment classification |

#### Marketplace Status & Operations

| Field | Meaning |
|---|---|
| `Is For Sale` | Boolean indicating if product is currently available |
| `Is Reserved` | Whether the item is reserved by a buyer |
| `Is On Shelf` | Physical warehouse/storage status |
| `Sale Type` | Type of sale (standard, auction, bundle, etc.) |
| `Sale Started At` | When the sale listing began |
| `Sales Channel` | Which Sellpy market (SE, DE, etc.) the product is listed in |
| `Storage Site` | Warehouse or fulfillment location code |
| `Item Packaging` | Packaging method or status |

#### Pricing & Financial Metrics

| Field | Meaning |
|---|---|
| `Pricing` | Base price in local currency |
| `Price SE` | Price in Swedish kronor (if applicable) |
| `Price Drop SE` | Discount amount or percentage reduction (Sweden market) |
| `First Offered At SE` | Initial offering price in SE market |
| `Featured In` | Premium placement or featured listing status |
| `Last Chance` | Indicator if listing is ending soon |

#### Engagement & Performance Metrics

| Field | Meaning |
|---|---|
| `Favourite Count` | Number of users who favorited the product |
| `Favorite Count Bucket` | Binned favorite count (e.g., 0-10, 11-50) |
| `Favorite Count Bucket Nordic` | Nordic market-specific favorite distribution |
| `Favorite Count Bucket DACH` | Germany/Austria/Switzerland market-specific buckets |
| `Favorite Count Bucket EU` | Broader EU engagement metrics |
| `Highlight Result` | Whether product is highlighted in search results |
| `Ranking Info` | Internal ranking score or tier |

#### Advanced Analytics Fields

| Field | Meaning |
|---|---|
| `Item AB Test Fraction` | A/B test cohort assignment for experimentation |
| `Relevance Ranking Normal Dist 15` | Relevance score for general search (standard distribution) |
| `Relevance Ranking Normal Dist 15 Similar Item` | Relevance when shown as similar product recommendation |
| `Proximity Bucket V1` / `Proximity Bucket V2` | Geographic proximity scoring versions |
| `P2P` | Peer-to-peer transaction indicator or rating |
| `Item IO` | Item input/output classification for operations |
| `Bag` | Bag/cart assignment or tracking |
| `Searchable External Category` | SEO or external category mapping |
| `Metadata` | Additional unstructured metadata |

***

### How to Use

1. **Find search URLs** — Navigate to Sellpy (.se, .de, or other regional domain) and perform product searches. Copy the full URL including filter parameters (e.g., category, size, price).
2. **Configure input** — Paste search URLs into the `urls` array. Adjust `max_items_per_url` to control extraction volume (e.g., `50` for quick tests, `200` for full dataset).
3. **Handle failures gracefully** — Set `ignore_url_failures: true` to skip broken or blocked URLs without stopping the entire run.
4. **Run the scraper** — Start the actor and monitor progress via the log console.
5. **Export and analyze** — Download results as JSON, CSV, or Excel for analysis in BI tools, spreadsheets, or databases.

**Best practices:**

- Use narrow search filters (e.g., specific brand, size range, price range) to focus data collection.
- Test with `max_items_per_url: 20` first to validate output structure.
- For large-scale collection, space requests over time to avoid rate limiting.

***

### Use Cases & Business Value

- **Fashion trend analysis:** Track which brands, styles, and materials gain traction in secondhand markets
- **Pricing intelligence:** Monitor price drops, discounts, and seasonal patterns across regions
- **Competitive benchmarking:** Analyze how competitor sellers price similar items
- **Inventory research:** Understand stock levels and product availability trends
- **Circular economy insights:** Study consumer preferences for sustainable fashion
- **Market expansion:** Identify underserved categories or geographic opportunities

By automating product data collection, teams eliminate weeks of manual research and unlock data-driven insights into the fast-growing secondhand fashion market.

***

### Conclusion

The **Sellpy Product Search Scraper** delivers comprehensive, machine-readable fashion marketplace data. With 50+ fields covering product attributes, pricing, and engagement metrics, it serves researchers, analysts, and businesses building tools in the circular economy space. Start scraping today to harness the power of Sellpy's rich product catalog.

# Actor input Schema

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

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.sellpy.se/search/Kvinna/Kl%C3%A4der/Kl%C3%A4nningar?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.sellpy.se/search/Kvinna/Kl%C3%A4der/Kl%C3%A4nningar?page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/sellpy-product-search-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 = {
    "urls": ["https://www.sellpy.se/search/Kvinna/Kl%C3%A4der/Kl%C3%A4nningar?page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/sellpy-product-search-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 '{
  "urls": [
    "https://www.sellpy.se/search/Kvinna/Kl%C3%A4der/Kl%C3%A4nningar?page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/sellpy-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sellpy Product Search Scraper",
        "description": "Scrape Sellpy.se product listings with 51+ data fields per item. Capture pricing, inventory status, brand info, images, customer favorites, and ranking metrics — perfect for market analysis, price monitoring, and resale business intelligence.",
        "version": "0.0",
        "x-build-id": "RQRpHlrmbcmgV0D9Y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~sellpy-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-sellpy-product-search-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/stealth_mode~sellpy-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-sellpy-product-search-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/stealth_mode~sellpy-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-sellpy-product-search-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",
                "properties": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
