# GoCollect Comic Price Guide Scraper (`crawlerbros/gocollect-comic-price-guide-scraper`) Actor

Scrape GoCollect's comic book price guide and sales-history data. Search by title/character, browse the Hot List, Key Issues, or newest additions, and filter by publisher and comic-book era. Returns pricing, creators, and publication metadata per comic.

- **URL**: https://apify.com/crawlerbros/gocollect-comic-price-guide-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## GoCollect Comic Price Guide Scraper

Scrape **GoCollect** — the comic-book price guide and sales-history platform. Search by
comic title or character, browse the Hot List of trending books, browse Key Issues, or
browse the newest additions. Get publisher, creator credits, publication date, comic-book
era, and historical sale price ranges per comic. HTTP-only, no login, no API key.

### What this actor does

- **Five modes:** `search`, `hottest`, `keyIssues`, `new`, `bySlug`
- **Publisher filter:** Marvel, DC Comics, Image Comics, Dark Horse, IDW, and more
- **Era filter:** Golden / Silver / Bronze / Copper / Modern Age, derived from publication date
- **Full price guide detail:** historical low/high sale price, offer count, cover price, page count
- **Creator credits:** writer(s), artist(s), penciler(s), inker(s), colorist(s), letterer(s), cover artist(s), editor(s)
- **Empty fields are omitted**

### Output per comic

- `slug` — GoCollect's URL slug for this comic
- `title` — comic title including issue number/variant, e.g. `Amazing Spider-Man #1`
- `description` — GoCollect's summary text for the comic
- `imageUrl` — cover image
- `category` — always `Comic`
- `seriesName`, `seriesUrl` — the comic's series, e.g. `Amazing Spider-Man`
- `variantCount` — number of known cover variants for this issue, when GoCollect tracks any
- `publisher` — e.g. `Marvel`, `DC Comics`
- `writers[]`, `artists[]`, `pencilers[]`, `inkers[]`, `colorists[]`, `letterers[]`, `coverArtists[]`, `editors[]`
- `publicationDate` — ISO date, when resolvable
- `publicationYear`
- `era` — `golden` / `silver` / `bronze` / `copper` / `modern`
- `decade` — e.g. `1960s`
- `coverPrice`, `coverPriceUsd` — original newsstand cover price
- `pageCount`
- `priceCurrency`, `lowPrice`, `highPrice`, `offerCount`, `priceRangeDescription` — historical sales-based price range, when available
- `sourceUrl` — the comic's GoCollect page
- `recordType: "comic"`, `scrapedAt`

Newly solicited/unreleased comics may not have sales history yet, so `lowPrice`/`highPrice`/`offerCount` are omitted rather than fabricated for those records.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `hottest` / `keyIssues` / `new` / `bySlug` |
| `searchQuery` | string | `spider-man` | Free-text title/character query (mode=search) |
| `comicUrls` | array | – | Comic URLs or bare slugs to look up (mode=bySlug) |
| `publisher` | string | `any` | Restrict to a publisher, or `any` |
| `era` | string | `any` | Restrict to a comic-book era, or `any` |
| `maxItems` | int | `20` | Hard cap on emitted records (1-200) |
| `proxyConfiguration` | object | AUTO | Optional Apify Proxy configuration |

#### Example: search by title, filter to Marvel Silver Age

```json
{
  "mode": "search",
  "searchQuery": "spider-man",
  "publisher": "Marvel",
  "era": "silver",
  "maxItems": 25
}
````

#### Example: browse the Hot List

```json
{
  "mode": "hottest",
  "maxItems": 50
}
```

#### Example: browse Key Issues filtered to DC Comics

```json
{
  "mode": "keyIssues",
  "publisher": "DC Comics",
  "maxItems": 30
}
```

#### Example: lookup specific comics by URL

```json
{
  "mode": "bySlug",
  "comicUrls": [
    "https://gocollect.com/comic/amazing-spider-man-1",
    "fantastic-four-1"
  ]
}
```

### Use cases

- **Collector price research** — check the current sales-based value range before buying or selling
- **Grading/investment tracking** — monitor Hot List and Key Issues movers over time
- **Dealer inventory pricing** — bulk-pull price ranges for a want list or inventory
- **Publisher/era collections** — build a dataset of a publisher's or era's key issues
- **Marketplace listing enrichment** — attach publication metadata and price context to comic listings

### Data source / limitations

Data comes from GoCollect's publicly accessible comic pages (search, Hot List, Key Issues,
New, and individual comic detail pages) — the same pages a visitor sees without logging in.
GoCollect's account-gated premium tools (portfolio tracking, custom alerts, and other
subscriber-only features) are out of scope and not accessed by this actor. Publisher and
era are only included on a record when GoCollect exposes that field for the comic; if a
comic's page doesn't list a publisher, the filter treats it as a non-match-excluding field
(it won't be wrongly filtered out just because the field is missing), consistent with how
every other filter in this actor behaves.

A comic detail page also shows a per-grade "Graded Population" (CGC/PSA census) panel and
a "What's it Worth?" grade-price breakdown; these render as perpetual loading placeholders
even with full JavaScript execution and never resolve without a paid data feed, so they are
not included — only the aggregate historical sale price range (`lowPrice`/`highPrice`)
that GoCollect publishes openly is captured.

### FAQ

**What is the data source?**
The public gocollect.com comic price guide. All data is GoCollect's own published pricing
and metadata.

**Is this affiliated with GoCollect?**
No. This is an independent third-party actor that reads GoCollect's public pages. It is not
affiliated with, endorsed by, or sponsored by GoCollect.

**What do the "eras" mean?**
Standard comic-collecting eras derived from publication year: Golden Age (1938-1955),
Silver Age (1956-1969), Bronze Age (1970-1984), Copper Age (1985-1991), and Modern Age
(1992-present).

**Why do some comics have no price range?**
GoCollect's price range is based on historical sales. Newly solicited or just-released
comics may not have any recorded sales yet, so no price range exists for them.

**Is the search exact or fuzzy?**
`search` performs the same relevance-ranked text search as typing into GoCollect's own
search box — it matches on title/character text, not an exact string.

**How fresh is the data?**
Data reflects GoCollect's live pages at the time the actor runs; price ranges update as
new sales are recorded.

**Are there rate limits?**
GoCollect is public and does not require an API key or login. The actor fetches politely
with small delays between requests.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

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

Free-text comic title or character query (mode=search), e.g. `spider-man` or `batman`.

## `comicUrls` (type: `array`):

Full GoCollect comic URLs or bare slugs, e.g. `https://gocollect.com/comic/amazing-spider-man-1` or `amazing-spider-man-1`.

## `publisher` (type: `string`):

Restrict results to a specific publisher.

## `era` (type: `string`):

Restrict results to a comic-book collecting era, derived from the publication date.

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

Hard cap on emitted records.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy (free AUTO datacenter group). GoCollect is public and does not require proxy, but this can help if datacenter IPs get rate-limited.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "spider-man",
  "comicUrls": [],
  "publisher": "any",
  "era": "any",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `comics` (type: `string`):

Dataset containing all scraped GoCollect comic records.

# 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 = {
    "mode": "search",
    "searchQuery": "spider-man",
    "comicUrls": [],
    "publisher": "any",
    "era": "any",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/gocollect-comic-price-guide-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 = {
    "mode": "search",
    "searchQuery": "spider-man",
    "comicUrls": [],
    "publisher": "any",
    "era": "any",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/gocollect-comic-price-guide-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 '{
  "mode": "search",
  "searchQuery": "spider-man",
  "comicUrls": [],
  "publisher": "any",
  "era": "any",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/gocollect-comic-price-guide-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/gocollect-comic-price-guide-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GoCollect Comic Price Guide Scraper",
        "description": "Scrape GoCollect's comic book price guide and sales-history data. Search by title/character, browse the Hot List, Key Issues, or newest additions, and filter by publisher and comic-book era. Returns pricing, creators, and publication metadata per comic.",
        "version": "1.0",
        "x-build-id": "hrOHmHoloaCiaciP4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~gocollect-comic-price-guide-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-gocollect-comic-price-guide-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/crawlerbros~gocollect-comic-price-guide-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-gocollect-comic-price-guide-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/crawlerbros~gocollect-comic-price-guide-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-gocollect-comic-price-guide-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "hottest",
                            "keyIssues",
                            "new",
                            "bySlug"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Title / character",
                        "type": "string",
                        "description": "Free-text comic title or character query (mode=search), e.g. `spider-man` or `batman`.",
                        "default": "spider-man"
                    },
                    "comicUrls": {
                        "title": "Comic URLs or slugs (mode=bySlug)",
                        "type": "array",
                        "description": "Full GoCollect comic URLs or bare slugs, e.g. `https://gocollect.com/comic/amazing-spider-man-1` or `amazing-spider-man-1`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "publisher": {
                        "title": "Publisher filter",
                        "enum": [
                            "any",
                            "Marvel",
                            "DC Comics",
                            "Image Comics",
                            "Dark Horse Comics",
                            "IDW Publishing",
                            "BOOM! Studios",
                            "Valiant Entertainment",
                            "Dynamite Entertainment",
                            "Archie Comics",
                            "Vertigo",
                            "Top Cow Productions",
                            "Oni Press",
                            "AfterShock Comics",
                            "Black Mask Studios",
                            "Avatar Press"
                        ],
                        "type": "string",
                        "description": "Restrict results to a specific publisher.",
                        "default": "any"
                    },
                    "era": {
                        "title": "Comic-book era filter",
                        "enum": [
                            "any",
                            "golden",
                            "silver",
                            "bronze",
                            "copper",
                            "modern"
                        ],
                        "type": "string",
                        "description": "Restrict results to a comic-book collecting era, derived from the publication date.",
                        "default": "any"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy (free AUTO datacenter group). GoCollect is public and does not require proxy, but this can help if datacenter IPs get rate-limited.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```