# Pricecharting Product Collection Scraper (`ecomscrape/pricecharting-product-collection-scraper`)

The Pricecharting.com Product Collection Scraper extracts detailed collection's product data from Pricecharting.com, including title, price, image URLs, product information, and more, in structured formats like JSON by providing collection urls.

- **URL**: https://beta-securitybyobscurity.apify.com/ecomscrape/pricecharting-product-collection-scraper.md
- **Developed by:** [ecomscrape](https://beta-securitybyobscurity.apify.com/ecomscrape) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.
You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

# README

## Contact

If you encounter any issues or need to exchange information, please feel free to contact us through the following link:
[My profile](https://apify.com/ecomscrape)

## What does Pricecharting.com Product Collection Scraper do?

PriceCharting.com stands as one of the most comprehensive pricing databases for collectibles, offering market values for video games, Pokemon cards, comics, and other trading card games. This platform has been providing price guides since 2007, utilizing algorithmic pricing to determine values for each item across different conditions. For market researchers, collectors, retailers, and investment analysts, accessing this wealth of pricing data systematically can provide crucial competitive intelligence and market insights.

The challenge lies in manually gathering this information across thousands of collectible items. With over 1,865 Pokemon Promo items alone tracked on the platform, manual data collection becomes impractical for comprehensive market analysis. This is where automated scraping becomes essential for businesses and researchers who need scalable access to pricing intelligence.

### Comprehensive PriceCharting Scraper Overview

The PriceCharting Product Collection Scraper is designed to extract detailed collectible information from any product collection page on PriceCharting.com. This tool addresses the critical need for systematic data collection from one of the collectibles industry's most trusted pricing sources.

The scraper excels in handling large-scale data extraction while respecting the website's structure and maintaining data accuracy. Built with enterprise-grade reliability, it incorporates proxy support, retry mechanisms, and rate limiting to ensure consistent performance without triggering anti-bot measures.

This solution serves collectors tracking market trends, retailers analyzing inventory pricing, investment firms researching collectible markets, and data analysts studying pricing patterns across different categories. The scraper's flexibility allows for targeted data collection from specific product collections, making it valuable for both broad market analysis and niche category research.

### Input Configuration and Requirements

Example url 1: https://www.pricecharting.com/console/pokemon-promo

Example url 2: https://www.pricecharting.com/console/magic-lord-of-the-rings

Example url 3: https://www.pricecharting.com/console/magic-bloomburrow

Example Screenshot of product collection page:

![](https://i.ibb.co/vLbBNXs/Screenshot-from-2025-01-21-00-58-39.png)

#### Input Format Structure

The scraper accepts JSON configuration with several key parameters that control the extraction process:

**Input:**

```json
{
  "max_retries_per_url": 2,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "SG"
  },
  "max_items_per_url": 20,
  "urls": [
    "https://www.pricecharting.com/console/pokemon-promo",
    "https://www.pricecharting.com/console/magic-lord-of-the-rings",
    "https://www.pricecharting.com/console/magic-bloomburrow"
  ]
}
```

**max\_retries\_per\_url**: Defines the maximum number of retry attempts for each URL when encountering connection issues or temporary failures. This ensures data collection reliability even when facing intermittent website issues.

**proxy configuration**: The proxy settings provide essential bot detection avoidance. Using residential proxies from countries matching your target market (like Singapore for Asian collectibles markets) helps maintain consistent access while appearing as legitimate traffic.

**max\_items\_per\_url**: Controls the number of items extracted from each collection page. This parameter helps manage processing time and resource usage, particularly useful when testing or working with large collections.

**urls array**: Contains the specific PriceCharting collection URLs to scrape. These must be valid collection pages like "/console/pokemon-promo" or "/console/nintendo-64" rather than individual item pages.

### Output Data Structure and Field Explanations

You get the output from the Pricecharting.com Product Collection Scraper stored in a tab. The following is an example of the Information Fields collected after running the Actor.

```json
[ // List of product information
  {
    "id": "5834844",
    "image_url": "https://www.pricecharting.com/game/pokemon-promo/pikachu-with-grey-felt-hat-85",
    "title": "Pikachu with Grey Felt Hat #85",
    "url": "https://www.pricecharting.com/game/pokemon-promo/pikachu-with-grey-felt-hat-85",
    "prices": [
      {
        "col_name": "Ungraded",
        "price_txt": "$283.65",
        "price_amount": 283.65,
        "currency": "$"
      },
      {
        "col_name": "Grade 9",
        "price_txt": "$299.50",
        "price_amount": 299.5,
        "currency": "$"
      },
      {
        "col_name": "PSA 10",
        "price_txt": "$654.23",
        "price_amount": 654.23,
        "currency": "$"
      }
    ],
    "position": 1,
    "from_url": "https://www.pricecharting.com/console/pokemon-promo"
  }, // ... Many other product details
]
```

The scraper returns structured data for each collectible item with six essential fields:

**ID**: A unique identifier for each item within the collection. This field enables database storage, duplicate detection, and reference tracking when updating datasets over time.

**Image URL**: Direct link to the primary product image hosted on PriceCharting's servers. These high-quality images are essential for visual product identification, marketplace listings, and inventory management systems.

**Title**: The complete product name including specific variants, conditions, or special editions. This field captures the exact naming convention used by PriceCharting, which is crucial for accurate price matching and market comparison.

**URL**: The direct link to the individual product's detailed page. This provides access to comprehensive pricing history, condition-specific values, and additional product details not captured in the collection view.

**Prices**: Comprehensive pricing data structure containing values for different conditions (loose, complete, new, graded) and time periods. This is the core value proposition, providing current market values and pricing trends.

**Position**: The item's ranking or position within the collection page. This indicates relative popularity, value ranking, or alphabetical positioning, which can be valuable for understanding market hierarchy and collection organization.

This output structure enables immediate integration into pricing databases, market analysis tools, and inventory management systems. The consistent format ensures reliable data processing across different collection types and categories.

### Implementation Guide and Best Practices

#### Step-by-Step Usage Process

1. **Identify Target Collections**: Navigate to PriceCharting.com and locate the specific collection URLs you want to scrape. Copy the complete URLs ensuring they point to collection pages rather than individual items.

2. **Configure Input Parameters**: Set appropriate retry limits (typically 2-3), configure proxy settings matching your geographical focus, and adjust item limits based on your processing capacity and requirements.

3. **Execute and Monitor**: Run the scraper while monitoring for any error messages or blocked requests. The tool provides status updates throughout the extraction process.

4. **Data Validation**: Review extracted data for completeness and accuracy, particularly checking that all expected fields are populated and prices are in expected formats.

#### Optimization Tips

For best results, limit concurrent requests and implement delays between collection URLs to avoid overwhelming the server. Use residential proxies from countries relevant to your market focus, as this can improve both success rates and data accuracy.

When working with large collections, consider segmenting your requests into smaller batches. This approach provides better error recovery and makes it easier to identify and resolve any issues that arise during extraction.

Monitor your success rates and adjust retry parameters accordingly. If you encounter frequent failures, increase retry counts or implement longer delays between requests.

#### Common Issue Resolution

If you encounter blocked requests or captcha challenges, verify your proxy configuration and consider rotating proxy countries. Sometimes switching from one residential proxy location to another can resolve access issues.

For incomplete data extraction, check that your target URLs are correctly formatted and point to active collection pages. PriceCharting occasionally reorganizes their URL structure, so verify current page accessibility.

When prices appear inconsistent or missing, this typically indicates the need for updated proxy settings or that the specific items have limited pricing data available on the platform.

### Business Value and Market Applications

#### Time and Resource Efficiency

Manual collection of comprehensive pricing data from PriceCharting would require hundreds of hours for large collections. This scraper reduces that time investment to minutes, enabling real-time market analysis and competitive intelligence gathering at scale.

The automation eliminates human error in data transcription and ensures consistent data formatting across all extracted items. This reliability is crucial for businesses making inventory or investment decisions based on market data.

#### Practical Applications

**Market Research**: Track pricing trends across different collectible categories to identify emerging opportunities or declining markets. Historical price tracking enables predictive analysis for investment decisions.

**Inventory Management**: Retailers can automatically update their pricing based on current market values, ensuring competitive positioning while maintaining profit margins.

**Portfolio Analysis**: Collectors and investors can monitor their collection values automatically, receiving data-driven insights into their portfolio performance over time.

**Competitive Intelligence**: Businesses can track competitor pricing strategies and market positioning by monitoring how similar items are valued across the platform.

The scraped data integrates seamlessly with business intelligence tools, spreadsheet applications, and custom database systems, providing flexibility for various analytical approaches and reporting needs.

### Conclusion

The PriceCharting Product Collection Scraper transforms manual data gathering into an automated, reliable process that delivers comprehensive market intelligence. By providing structured access to one of the collectibles industry's most trusted pricing sources, this tool enables data-driven decision-making for collectors, retailers, and investors alike.

Ready to streamline your collectible market research? Configure your target collections and start extracting valuable pricing intelligence today.

## Relate Actors

[**Pricecharting.com Product Collection Price History Scraper**](https://apify.com/ecomscrape/pricecharting-product-collection-price-history-scraper): A specialized tool that allows you to extract detailed product collection price history data directly from the Pricecharting.com platform.

[**Pricecharting.com Product Details Page Scraper**](https://apify.com/ecomscrape/pricecharting-product-details-page-scraper): A specialized tool that allows you to extract detailed product data directly from the Pricecharting.com platform.

## Your feedback

We are always working to improve Actors' performance. So, if you have any technical feedback about Pricecharting.com Product Collection Scraper or simply found a bug, please create an issue on the Actor's Issues tab in Apify Console.

# Actor input Schema

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

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

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

Select your total items you want to scrape data.

## `max_retries_per_url` (type: `integer`):

Limit the number of retries for each URL if the scrape is detected as a bot or the page fails to load

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

Select proxies to be used by your scraper.

## Actor input object example

```json
{
  "urls": [
    "https://www.pricecharting.com/console/pokemon-promo"
  ],
  "max_items_per_url": 20,
  "max_retries_per_url": 2,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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.pricecharting.com/console/pokemon-promo"
    ],
    "max_retries_per_url": 2,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ecomscrape/pricecharting-product-collection-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.pricecharting.com/console/pokemon-promo"],
    "max_retries_per_url": 2,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ecomscrape/pricecharting-product-collection-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.pricecharting.com/console/pokemon-promo"
  ],
  "max_retries_per_url": 2,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ecomscrape/pricecharting-product-collection-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pricecharting Product Collection Scraper",
        "description": "The Pricecharting.com Product Collection Scraper extracts detailed collection's product data from Pricecharting.com, including title, price, image URLs, product information, and more, in structured formats like JSON by providing collection urls.",
        "version": "0.0",
        "x-build-id": "AJEgXqcW5RHKCIPKf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ecomscrape~pricecharting-product-collection-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ecomscrape-pricecharting-product-collection-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/ecomscrape~pricecharting-product-collection-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ecomscrape-pricecharting-product-collection-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/ecomscrape~pricecharting-product-collection-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ecomscrape-pricecharting-product-collection-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 collection urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Product collection 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"
                        }
                    },
                    "max_items_per_url": {
                        "title": "Total items to scrape",
                        "type": "integer",
                        "description": "Select your total items you want to scrape data.",
                        "default": 20
                    },
                    "max_retries_per_url": {
                        "title": "Limit the number of retries for each URL",
                        "type": "integer",
                        "description": "Limit the number of retries for each URL if the scrape is detected as a bot or the page fails to load"
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your scraper."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
