# Linktree Commerce & Product Block Scraper (`vsekar91/linktree-products-scraper`) Actor

Extract monetization blocks from Linktree profiles: product payments, storefronts, tip jars, donation links, payment requests, and heuristic-matched commerce links (Shopify, Gumroad, Stripe, Etsy, Spring, Bonfire). No login required.

- **URL**: https://apify.com/vsekar91/linktree-products-scraper.md
- **Developed by:** [Venkatesh Sekar](https://apify.com/vsekar91) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Linktree Commerce & Product Block Scraper

Extract **monetization and commerce blocks** from public Linktree profiles — the only Apify actor focused exclusively on how creators make money through their Linktree pages.

**No login. No API key. Paste usernames and get structured commerce data.**

---

### What makes this different

Every other Linktree scraper on Apify extracts the basic link list. This actor parses the same page but filters and enriches *only* the commerce-relevant blocks:

| Block type | What it represents |
|---|---|
| `COMMERCE_PAY` | Native Stripe product purchase (price, currency, gateway) |
| `COMMERCE_LINK` | Linked storefront / product page |
| `PAYMENT_REQUEST` | Creator payment request block |
| `DONATION_LINK` / `TIP_JAR` | Donation and tip-jar blocks |
| `SHOPIFY` | Embedded Shopify store |
| `SPRING` / `BONFIRE` | Merch storefronts (Spring/Teespring, Bonfire) |
| `GUMROAD` | Gumroad product embed |
| heuristic match | Classic links pointing to Stripe, Etsy, Gumroad, Ko-fi, Buy Me a Coffee, PayPal.me, Venmo, Cashapp, Fourthwall, Patreon, GoFundMe, etc. |

---

### What you get

For each profile:

- **Profile** — username, display name, bio, avatar, verified status, social links
- **Commerce blocks** — every monetization block with: `block_type`, `commerce_category`, `title`, `url`, `price_amount`, `currency`, `stripe_account_id`, `button_text`, `gateway`, `payment_platform`
- **Summary counts** — `total_link_count`, `commerce_block_count`
- **Optional** — full non-commerce link list, raw `__NEXT_DATA__` for schema debugging

### Example output

```json
{
  "url": "https://linktr.ee/mrbeast",
  "username": "mrbeast",
  "display_name": "MrBeast",
  "bio": "...",
  "verified": true,
  "total_link_count": 18,
  "commerce_block_count": 4,
  "commerce_blocks": [
    {
      "block_id": "123456",
      "block_type": "COMMERCE_PAY",
      "commerce_category": "product",
      "title": "Feastables Chocolate Bar",
      "url": "https://feastables.com/...",
      "price_amount": 2.99,
      "currency": "USD",
      "stripe_account_id": "acct_xxxxxxxx",
      "button_text": "Buy Now",
      "gateway": "stripe",
      "position": 3,
      "enabled": true
    },
    {
      "block_id": "789012",
      "block_type": "CLASSIC",
      "commerce_category": "commerce_link",
      "title": "Shop MrBeast Merch",
      "url": "https://shopify.com/mrbeast",
      "price_amount": null,
      "currency": null,
      "position": 5,
      "enabled": true
    }
  ],
  "instagram": "mrbeast",
  "youtube": "MrBeast"
}
````

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `profiles` | string list | Yes | — | Usernames or full URLs, e.g. `mrbeast` or `https://linktr.ee/mrbeast` |
| `includeAllLinks` | boolean | No | `false` | Also return a cleaned list of all non-commerce links |
| `includeRawBlocks` | boolean | No | `false` | Attach raw `__NEXT_DATA__` blocks (debugging) |
| `maxConcurrency` | integer | No | `3` | Parallel fetches (max 10) |
| `proxyConfiguration` | object | No | Residential | Proxy config — residential IPs strongly recommended |

### Output fields

| Field | Description |
|---|---|
| `url` | Canonical Linktree profile URL |
| `username` | Linktree handle |
| `display_name` | Creator's display name |
| `bio` | Profile bio text |
| `avatar` | Profile picture URL |
| `verified` | Linktree verified badge |
| `instagram` / `tiktok` / `youtube` / `twitter` / `facebook` | Social links |
| `total_link_count` | Total blocks on the page |
| `commerce_block_count` | Number of commerce blocks found |
| `commerce_blocks[]` | Array of commerce blocks (see fields below) |
| `theme_name` | Active Linktree theme |
| `background_color` | Theme background color |

#### Commerce block fields

| Field | Description |
|---|---|
| `block_id` | Linktree internal block ID |
| `block_type` | Raw Linktree block type string |
| `commerce_category` | Normalized category: `product`, `storefront`, `donation`, `payment_request`, `merch`, `commerce_link` |
| `title` | Block display title |
| `url` | Target URL |
| `thumbnail` | Block image URL |
| `position` | Display order on profile |
| `enabled` | Whether the block is active |
| `price_amount` | Price (for COMMERCE\_PAY blocks) |
| `currency` | ISO currency code |
| `stripe_account_id` | Connected Stripe account (when present) |
| `description` | Block description text |
| `button_text` | CTA button text |
| `gateway` | Payment gateway identifier |
| `payment_platform` | Platform name |
| `scheduling_rules` | Time-gated display rules |
| `meta_raw` | Raw meta object (when present) |

### Proxy notes

Linktree blocks most datacenter IP ranges. For reliable results on large runs use **Apify Residential Proxies** (`RESIDENTIAL` group). The default input prefills this configuration. For small test runs (< 20 profiles) datacenter proxies may work if the IPs are clean.

### Use cases

- **Creator commerce intelligence** — which creators on your target list are actively selling products? What prices?
- **Stripe adoption research** — identify creators using Linktree's native Stripe checkout vs. off-platform storefronts
- **Merch platform market share** — Spring vs. Bonfire vs. Shopify adoption among creator categories
- **Tip-jar / donation mapping** — find creators with active donation flows (Ko-fi, Buy Me a Coffee, Linktree native)
- **Commerce platform prospecting** — find creators ready to be pitched on a new e-commerce solution

### Pricing

Charged per successful profile result using Apify's Pay-Per-Event model.

### Related actors in this suite

- **Stan.store Creator Scraper** — full product catalog, pricing, and reviews from Stan.store storefronts
- **Beacons.ai Commerce Block Scraper** — product blocks from Beacons pages
- **Fanvue Creator Scraper** — subscription tiers and profile data from Fanvue

### Notes

- Scrapes public Linktree pages only. No credentials required.
- Private or deleted profiles return an error record with the HTTP status.
- Linktree updates their frontend periodically. If `error: parse_failed` appears, the `__NEXT_DATA__` schema may have changed — enable `includeRawBlocks` on one profile and inspect `raw_account` to locate the new key paths.

# Actor input Schema

## `profiles` (type: `array`):

Linktree usernames or full profile URLs, e.g. "mrbeast" or "https://linktr.ee/mrbeast". Each entry produces one result row.

## `includeAllLinks` (type: `boolean`):

Also return a cleaned list of all non-commerce blocks on the page (all\_links field). Useful for a full link inventory alongside commerce data.

## `includeRawBlocks` (type: `boolean`):

Attach the raw links array and account object from Linktree's **NEXT\_DATA** JSON. Verbose — use only for debugging or schema-change detection.

## `maxConcurrency` (type: `integer`):

Number of profiles to fetch in parallel. Linktree rate-limits aggressively — residential proxies recommended for large runs.

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

Proxy used for outbound requests. Linktree blocks datacenter IPs — use Apify residential proxies (RESIDENTIAL group) for reliable results.

## Actor input object example

```json
{
  "profiles": [
    "mrbeast"
  ],
  "includeAllLinks": false,
  "includeRawBlocks": false,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("vsekar91/linktree-products-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 = { "profiles": ["mrbeast"] }

# Run the Actor and wait for it to finish
run = client.actor("vsekar91/linktree-products-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 '{
  "profiles": [
    "mrbeast"
  ]
}' |
apify call vsekar91/linktree-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linktree Commerce & Product Block Scraper",
        "description": "Extract monetization blocks from Linktree profiles: product payments, storefronts, tip jars, donation links, payment requests, and heuristic-matched commerce links (Shopify, Gumroad, Stripe, Etsy, Spring, Bonfire). No login required.",
        "version": "0.1",
        "x-build-id": "ktCODl4ANjVR6RGen"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vsekar91~linktree-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vsekar91-linktree-products-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/vsekar91~linktree-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-vsekar91-linktree-products-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/vsekar91~linktree-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-vsekar91-linktree-products-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": [
                    "profiles"
                ],
                "properties": {
                    "profiles": {
                        "title": "Linktree profiles",
                        "type": "array",
                        "description": "Linktree usernames or full profile URLs, e.g. \"mrbeast\" or \"https://linktr.ee/mrbeast\". Each entry produces one result row.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeAllLinks": {
                        "title": "Include all links (not just commerce)",
                        "type": "boolean",
                        "description": "Also return a cleaned list of all non-commerce blocks on the page (all_links field). Useful for a full link inventory alongside commerce data.",
                        "default": false
                    },
                    "includeRawBlocks": {
                        "title": "Include raw __NEXT_DATA__ blocks",
                        "type": "boolean",
                        "description": "Attach the raw links array and account object from Linktree's __NEXT_DATA__ JSON. Verbose — use only for debugging or schema-change detection.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent fetches",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of profiles to fetch in parallel. Linktree rate-limits aggressively — residential proxies recommended for large runs.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for outbound requests. Linktree blocks datacenter IPs — use Apify residential proxies (RESIDENTIAL group) for reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
