> ## Documentation Index
> Fetch the complete documentation index at: https://docs.parse.bot/llms.txt
> Use this file to discover all available pages before exploring further.

# Marketplace

> Search thousands of pre-built APIs before you build your own

The Parse marketplace is a public catalog of pre-built APIs. Before you build an API from scratch, search the marketplace — if a site is already covered, you can use it instantly and for free.

Browse it two ways:

* **In the browser** — [parse.bot/marketplace](https://parse.bot/marketplace) (the "Discover" tab in the dashboard). Search, filter by category, and preview every endpoint.
* **Over the API** — the public REST endpoints below. No API key required.

## Why it exists: the canonical model

Every site in Parse has one shared, community-maintained API called the **canonical**. When you create an API for a site that already has a canonical, you get your own **copy** (a clone) linked back to it:

* The build is **instant and free** — the work is already done.
* You can **pull upstream improvements** as the canonical gets better (new endpoints, fixes). See [API Updates](/updates).
* Your revisions can flow **back** to the canonical, improving it for everyone.

This is controlled by the `contributes_to_marketplace` flag on `POST /dispatch` (default `true`). Set it to `false` only if you want a fully private, desynced API — that build is charged and the choice is permanent.

## Search APIs

```bash theme={null}
curl "https://api.parse.bot/marketplace/apis?q=amazon&limit=10"
```

Query parameters:

| Param      | Default | Description                                                                     |
| ---------- | ------- | ------------------------------------------------------------------------------- |
| `q`        | —       | Free-text search across name, description, and endpoints. Omit to browse.       |
| `category` | —       | Filter by category slug.                                                        |
| `sort`     | `top`   | Ordering when browsing: `top` (highest rated), `recent` (newest), `name` (A→Z). |
| `country`  | —       | ISO-2 code (e.g. `US`) for region-aware ranking.                                |
| `semantic` | `true`  | Include semantic (embedding) ranking when searching.                            |
| `limit`    | `50`    | 1–200.                                                                          |
| `offset`   | `0`     | For pagination.                                                                 |

Response:

```json theme={null}
{
  "items": [
    {
      "id": "mp-789",
      "slug": "amazon-product-search",
      "name": "Amazon Product Search",
      "description": "Search products and fetch details, prices, and reviews",
      "source_url": "https://www.amazon.com",
      "is_authenticated": false,
      "endpoint_count": 4,
      "primary_category": "ecommerce",
      "secondary_categories": ["retail"],
      "endpoint_preview": [
        { "endpoint_name": "search_products", "method": "POST", "summary": "Search by keyword" }
      ]
    }
  ],
  "total": 1,
  "limit": 10,
  "offset": 0
}
```

## Search individual endpoints

When you know the *data* you want but not which API has it, search across endpoints directly:

```bash theme={null}
curl "https://api.parse.bot/marketplace/search-endpoints?q=flight%20prices"
```

This returns two groups — matching APIs and matching endpoints — so you can jump straight to the right endpoint. Params: `q` (required, 1–120 chars), `api_limit` (default 6), `endpoint_limit` (default 12), `country`.

## Using a marketplace API

There are four ways to consume a marketplace API, depending on whether you want your own copy and whether you want to stay in sync with the canonical.

| Path                            | Endpoint                                          | Your own copy?       | Version                  | Shows in My APIs |
| ------------------------------- | ------------------------------------------------- | -------------------- | ------------------------ | ---------------- |
| **Call the canonical directly** | `POST /scraper/{canonical_scraper_id}/{endpoint}` | No                   | Always latest            | No               |
| **Subscribe**                   | `POST /marketplace/apis/{id}/subscribe`           | Yes (pinned clone)   | Pinned at subscribe time | Yes              |
| **Fork privately**              | `POST /marketplace/apis/{id}/fork`                | Yes (desynced clone) | Independent              | Yes              |
| **Dispatch by URL**             | `POST /dispatch` with the `source_url`            | Yes (clone)          | Pinned at build time     | Yes              |

### 1. Call the canonical directly (simplest)

Every marketplace API has a shared **canonical** scraper that *any* user can call with just their API key — no subscribe or fork needed. Get its `canonical_scraper_id` (and endpoint list) from the detail endpoint, then call it:

```bash theme={null}
# Look up the canonical id + endpoints for a listing
curl "https://api.parse.bot/marketplace/apis/{id}"

# Call it directly — always runs the latest canonical
curl -X POST https://api.parse.bot/scraper/{canonical_scraper_id}/{endpoint_name} \
  -H "X-API-Key: $PARSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ ... }'
```

You always run the latest canonical, it doesn't appear in My APIs, and you can't pin a version. Great for quick, stateless use.

### 2. Subscribe — get your own pinned copy

`POST /marketplace/apis/{id}/subscribe` creates your own copy of the canonical, **pinned to its current release**, and adds it to My APIs. The response gives you a `scraper_id` to call:

```bash theme={null}
curl -X POST https://api.parse.bot/marketplace/apis/{id}/subscribe \
  -H "X-API-Key: $PARSE_API_KEY"
# → { "scraper_id": "...", "canonical_scraper_id": "..." }
```

Because it's pinned, upstream changes won't alter your contract until you choose to [merge updates](/updates). Subscriptions stay sync-eligible, so improvements can flow both ways.

### 3. Fork privately — an isolated copy

`POST /marketplace/apis/{id}/fork` creates a **private, desynced** copy: no upstream merges, and your revisions don't propagate back to the canonical. Use this when you want to customize freely without being tied to the shared version:

```bash theme={null}
curl -X POST https://api.parse.bot/marketplace/apis/{id}/fork \
  -H "X-API-Key: $PARSE_API_KEY"
# → { "scraper_id": "...", "canonical_scraper_id": "..." }
```

### 4. Dispatch by URL

If you have a URL and don't know whether it's already in the marketplace, just `POST /dispatch` with it. If a canonical exists you get your own clone back instantly (`matched: true`); otherwise Parse builds one. See the [Quickstart](/quickstart).

<Tip>
  AI agents can do all of this through the [MCP server](/mcp) with the `marketplace_search`, `marketplace_subscribe`, and `call_endpoint` tools — no manual polling.
</Tip>