# Delcampe Collectibles Marketplace Listings Scraper (`jungle_synthesizer/delcampe-collectibles-marketplace-listings-scraper`) Actor

Structured listing data from Delcampe, Europe's largest collectables marketplace, across stamps, coins, postcards, militaria and 25+ other categories. Each row carries pricing, auction state, seller and category detail for building price comps and dealer maps.

- **URL**: https://apify.com/jungle\_synthesizer/delcampe-collectibles-marketplace-listings-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 record 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Delcampe Collectibles Marketplace Listings Scraper

Structured listing data from [Delcampe](https://www.delcampe.net/en_GB/collectables/), Europe's largest collectables marketplace — stamps, coins and banknotes, postcards, militaria, phonecards, trading cards, historical documents, and dozens more categories. Each row carries price, auction state, seller detail and full category path, built for price comps and dealer/supplier mapping rather than casual browsing.

***

### Delcampe Scraper Features

- Covers all top-level Delcampe categories — stamps, coins & banknotes, postcards, militaria, books & magazines, old paper, phonecards, and 55+ more.
- Returns both auction and fixed-price listings, with bid count, starting price, and current price on every auction row.
- Seller block on every record — username, country, feedback count, and professional-seller flag — the fields that turn a listing feed into a supplier map.
- Category path, condition, country-of-origin, and year/period pulled straight from the listing so rows work as price comps without a second lookup.
- Full-size image URLs on every listing.
- Narrow to specific categories, or leave the filter empty for full site coverage.

***

### Who Uses Delcampe Marketplace Data?

- **Philatelic and numismatic dealers** building a pricing book across stamps, coins, and banknotes.
- **Auction houses** setting reserves against live European secondary-market comps.
- **Insurers and appraisers** valuing estate collections against current asking and closing prices.
- **Collectibles marketplaces and aggregators** filling out a European supply feed alongside other auction sources.
- **Researchers and market analysts** tracking category-level pricing trends over time.

***

### How Delcampe Collectibles Marketplace Listings Scraper Works

1. Pick one or more categories, or leave the field empty to cover the whole site.
2. Set `maxItems` for how many listing records you want.
3. The scraper works through each category's listing pages, pulling every item it finds — title, price, seller, category path, condition, and images — until it reaches your cap.
4. Records stream into the dataset as flat JSON.

***

### Input

```json
{
    "maxItems": 500,
    "categories": ["stamps", "coins-banknotes"]
}
```

| Field        | Type    | Default | Description |
|--------------|---------|---------|-----------------------------------------------------------------------------------------------------------------|
| `maxItems`   | integer | `10`    | Cap on records returned, 1–200000. |
| `categories` | array   | `[]`    | Top-level categories to include — `stamps`, `postcards`, `coins-banknotes`, `army-war`, and 59 more. Empty = every category. |

***

### Delcampe Marketplace Scraper Output Fields

```json
{
    "item_id": "2632430408",
    "item_url": "https://www.delcampe.net/en_GB/collectables/stamps/france/postmark-collection/18491876-classic-period/lettre-affranchi-avec-un-timbre-no-3-de-france-superbe-2632430408.html",
    "title": "LETTRE  AFFRANCHI AVEC UN TIMBRE  No 3  DE  FRANCE     SUPERBE",
    "category_path": ["Stamps", "Europe", "France", "Postmark Collection", "1849-1876: Classic period"],
    "sale_type": "auction",
    "current_price": 26,
    "currency": "EUR",
    "starting_price": null,
    "bid_count": 2,
    "buy_now_price": null,
    "shipping_cost": null,
    "seller_username": "markcollection",
    "seller_country": "France",
    "seller_feedback_count": 8394,
    "seller_is_pro": false,
    "lot_condition": null,
    "country_of_origin": "france",
    "year_or_period": "1849-1876",
    "starts_at": "Saturday, 19 September 2026 at 09:26",
    "ends_at": "Saturday, 26 September 2026 at 02:42",
    "is_sold": false,
    "sold_price": null,
    "image_urls": [
        "https://www.delcampe.net/static/img_large/auction/002/632/430/408_001.jpg?v=1"
    ],
    "description": "LETTRE",
    "scraped_at": "2026-09-21T11:47:27.592Z"
}
```

| Field                   | Type    | Description                                                                |
|-------------------------|---------|----------------------------------------------------------------------------|
| `item_id`               | string  | Delcampe's numeric listing id, stable across locale variants.              |
| `item_url`              | string  | Canonical listing URL.                                                     |
| `title`                 | string  | Listing title.                                                             |
| `category_path`         | array   | Breadcrumb category path, root to leaf.                                    |
| `sale_type`             | string  | `auction` or `fixed_price`.                                                |
| `current_price`         | number  | Current asking/bid price, in the listing's own currency.                   |
| `currency`              | string  | Currency code shown on the listing (e.g. `EUR`, `GBP`, `USD`).             |
| `starting_price`        | number  | Auction starting price — populated only when no bids have been placed yet. |
| `bid_count`             | integer | Number of bids placed so far (auctions only).                              |
| `buy_now_price`         | number  | Buy-it-now price, when the seller offers one alongside bidding.            |
| `shipping_cost`         | number  | Shipping cost as listed by the seller, when stated as a flat figure.       |
| `seller_username`       | string  | Seller's Delcampe nickname.                                                |
| `seller_country`        | string  | Seller's listed location.                                                  |
| `seller_feedback_count` | integer | Seller's total feedback count.                                             |
| `seller_is_pro`         | boolean | True for sellers carrying Delcampe's professional/self-employed badge.     |
| `lot_condition`         | string  | Condition, when stated (used, unused, mint, cancelled, etc).               |
| `country_of_origin`     | string  | Country implied by the item's category, when the category is geographic.   |
| `year_or_period`        | string  | Year or period implied by the item's category, when present.               |
| `starts_at`             | string  | Sale start timestamp as shown on the listing.                              |
| `ends_at`               | string  | Sale end timestamp as shown on the listing.                                |
| `is_sold`               | boolean | True if the listing shows a completed/sold state at scrape time.           |
| `sold_price`            | number  | Final sold price, only populated when `is_sold` is true.                   |
| `image_urls`            | array   | Full-size listing image URLs.                                              |
| `description`           | string  | Seller's free-text item description.                                       |
| `scraped_at`            | string  | ISO timestamp this record was collected.                                   |

***

### Resuming a large crawl

Every run emits a `resumeCursor` in its Output. If a large crawl stops before it finishes — because it hit `maxItems`, your spend cap (`maxTotalChargeUsd`), or was aborted — start a new run with **the same input** plus that `resumeCursor` to continue from where it left off. The crawl resumes from the queued work the previous run didn't reach.

- You are **not re-charged** for records the earlier run already delivered.
- Resume within your account's run-retention window — on the free tier, roughly your 10 most recent runs. Once the source run is pruned, its `resumeCursor` is no longer valid.
- `resumeCursor` is opaque — supply it unmodified.

***

### FAQ

#### How do I scrape Delcampe listings?

Set `maxItems` and, optionally, `categories` to narrow the crawl. Leave `categories` empty to cover the whole site. The scraper returns flat JSON — price, seller, category, and condition on every row.

#### Does this cover both auctions and fixed-price listings?

Yes. Every record carries `sale_type` so you can filter or split auction vs. fixed-price rows downstream, along with bid count and starting price for auctions.

#### Can I limit the crawl to one category, like stamps or coins?

Yes. Set `categories` to any combination of top-level categories — `["stamps"]`, `["coins-banknotes", "postcards"]`, and so on. Leaving it empty scrapes every category.

#### How fresh is the data?

Every record reflects the listing as it stood at scrape time, including current price and bid count for live auctions.

#### What if I need more than one run's worth of data?

Use `resumeCursor` to continue a large crawl across multiple runs without re-paying for records you already have — see "Resuming a large crawl" above.

***

### Need More Features?

Need additional fields, a different category grouping, or scheduling on a cron? File an issue on the actor page or get in touch.

### Why Use Delcampe Collectibles Marketplace Listings Scraper?

- **Full-site coverage** — every top-level category, not just stamps or just postcards.
- **Built for price comps** — auction/fixed-price state, bid count, and sold state turn the feed into pricing data, not a shopping list.
- **Seller block on every row** — country, feedback count, and professional-seller flag map the supply side of the market, not just the listings.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

What will this data feed? E.g. lead lists, KYB checks, price tracking.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

We'll personally help with your use case. No spam.

## `resumeCursor` (type: `string`):

Leave empty for a fresh crawl. To CONTINUE a previous run where it stopped — without paying again for records you already received — paste the `resumeCursor` value from that run's Output (the run's OUTPUT key). Resume promptly: the previous run's data expires with your account's retention window (free tier: your ~10 most recent runs).

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

Maximum number of listing records to scrape.

## `categories` (type: `array`):

Optional. Limit the crawl to specific top-level Delcampe categories (Stamps, Coins & Banknotes, Postcards, etc). Leave empty to crawl every category site-wide.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10,
  "categories": []
}
```

# Actor output Schema

## `results` (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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10,
    "categories": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/delcampe-collectibles-marketplace-listings-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10,
    "categories": [],
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/delcampe-collectibles-marketplace-listings-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10,
  "categories": []
}' |
apify call jungle_synthesizer/delcampe-collectibles-marketplace-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_synthesizer/delcampe-collectibles-marketplace-listings-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OhAFSrIzbrYmAP7JK/builds/76bFbDeF0btvnZDhm/openapi.json