# DripShop Scraper (`epicscrapers/dripshop-live-scraper`) Actor

\[$1/1000] Scrape trading cards, box breaks, and live stream data from dripshop.live - the marketplace for Pokémon, sports cards, and Magic auctions. Extract prices, stock, seller ratings, stream metadata, NFTs, and instant pack details in structured JSON for analytics and price tracking.

- **URL**: https://apify.com/epicscrapers/dripshop-live-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** E-commerce, Developer tools, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Dripshop.live Scraper

The Dripshop.live Scraper extracts products, box breaks, streams, and user data from [dripshop.live](https://www.dripshop.live), a marketplace for trading card live sales, box breaks, and auctions. Enter a search query and get structured data on products, their pricing, stock levels, seller information, and more.

### What can the Dripshop.live Scraper do?

- Search products on dripshop.live by keyword query (e.g., "pokemon", "sports cards", "magic")
- Extract detailed product information including name, price, description, stock count, images, and tags
- Retrieve seller and broadcaster profiles with ratings and verification status
- Collect live stream and past stream metadata
- Extract NFT listings and instant pack data
- Gather box break listings including spot mappings, pricing, and availability

### What data can you extract from Dripshop.live?

| Data Category | Fields |
|---|---|
| Product | ID, name, slug, SKU, price, list price, image URL, description, stock count, sale type, item type, status, tags, timestamps |
| Seller/User | ID, name, slug, profile picture, ratings, verification status, live status, follower data |
| Stream | ID, title, slug, start/end times, viewer count, likes, host info, preview media |
| Box Break | ID, title, description, image, category, format, pricing, spot mappings, availability, stream association |
| NFT | ID, name, slug, SKU, price, image, description, stock, sale type |
| Instant Pack | ID, title, description, image, category, format, status, pricing |

### How to scrape Dripshop.live with the Dripshop.live Scraper

1. Open the [Dripshop.live Scraper](https://console.apify.com/actors) on Apify Console.
2. Enter one or more search queries in the **Query** field (e.g., "pokemon", "sports cards", "magic the gathering").
3. Set the **Max Items Per Query** limit to control how many results to retrieve.
4. Click **Run** and wait for the scraping to complete.
5. Download your dataset in JSON, CSV, Excel, or HTML format.

### Input

The Actor accepts two input fields:

- **Query** (required) -- One or more search terms to query products and listings on dripshop.live. For example, "pokemon", "baseball", "football", or "magic".
- **Max Items Per Query** (optional, default: 100) -- The maximum number of product results to return per search query. Higher values return more data but may take longer to process.

### Output

Each result is a product object containing its full metadata. Here is a sample of one product record:

```json
{
  "id": 2571565,
  "slug": "pokemon-go-pokemon-center-etb",
  "sku": "550",
  "name": "Pokemon GO Pokemon Center ETB",
  "price": 219.99,
  "list_price": null,
  "image": "https://cdn.dripshop.live/product/UcWXVB7-ZzSGCwLPeQhBE.webp",
  "description": "X1 Sealed Pokemon GO Pokemon Center ETB",
  "items_in_stock": 2,
  "sale_type": "sale",
  "item_type": "RIP",
  "user_id": 52296,
  "status": "active",
  "tags": ["pokemon"],
  "is_live": false
}
````

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from the Apify Console after a run completes.

### Is it legal to scrape Dripshop.live?

This Actor only extracts publicly available data from dripshop.live's search API, the same information visible to any visitor browsing the marketplace. It does not access private user data, login-protected pages, or personal information such as email addresses or phone numbers. You should review dripshop.live's terms of service before scraping and use the data responsibly.

All extracted data is already publicly accessible through the platform's search functionality. The Actor simply automates the retrieval of this public information.

### Why use the Dripshop.live Scraper instead of searching manually?

Manually browsing dripshop.live for products, comparing listings across sellers, and tracking prices is time-consuming. The Dripshop.live Scraper automates this process, letting you collect structured data across multiple search queries in a single run. You can schedule regular runs to track inventory changes, price fluctuations, and new listings over time. The Apify platform provides API access, webhook triggers, and integrations with tools like Google Sheets, Make, and Zapier for downstream processing.

### FAQ

#### How do I search for multiple categories at once?

Enter multiple queries in the Query field, one per line. For example, entering "pokemon" and "baseball" will return results for both searches in a single run.

#### Does this scrape all products on dripshop.live?

The Actor searches using the platform's search API, returning results relevant to the queries you enter. To get comprehensive results across many categories, enter multiple queries covering the topics you need.

#### What types of listings are returned?

Results include standard products for sale, box break spots, NFT listings, and instant packs. Each type includes its relevant metadata such as pricing, stock, seller information, and timestamps.

#### Can I run this on a schedule?

Yes, Apify supports scheduling. You can set the Dripshop.live Scraper to run daily, weekly, or at any custom interval to track changes in listings and pricing over time.

### Related Actors

This Actor is part of a collection of marketplace scraping tools. Check the Apify Store for other scraping solutions for trading card and collectible marketplaces.

### Support

If you encounter any issues or have feature requests, please visit the [Issues](https://github.com/jaredwray/dripshop-live-scraper/issues) section of the project repository. For custom scraping solutions or questions about extending the Actor, feel free to open an issue or reach out through the Apify platform.

# Actor input Schema

## `query` (type: `array`):

Enter your query

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

Maximum number of items to scraper per query

## Actor input object example

```json
{
  "query": [
    "pokemon"
  ],
  "maxItems": 100
}
```

# 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 = {
    "query": [
        "pokemon"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/dripshop-live-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 = { "query": ["pokemon"] }

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/dripshop-live-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 '{
  "query": [
    "pokemon"
  ]
}' |
apify call epicscrapers/dripshop-live-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DripShop Scraper",
        "description": "[$1/1000] Scrape trading cards, box breaks, and live stream data from dripshop.live - the marketplace for Pokémon, sports cards, and Magic auctions. Extract prices, stock, seller ratings, stream metadata, NFTs, and instant pack details in structured JSON for analytics and price tracking.",
        "version": "0.0",
        "x-build-id": "qI6jZ7XweKELm44Ws"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~dripshop-live-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-dripshop-live-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/epicscrapers~dripshop-live-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-dripshop-live-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/epicscrapers~dripshop-live-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-dripshop-live-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": {
                    "query": {
                        "title": "Query",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Enter your query",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items Per Query",
                        "type": "integer",
                        "description": "Maximum number of items to scraper per query",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
