# Linktree Profile Scraper (`automation-lab/linktree-profile-scraper`) Actor

Extract public Linktree profile bios, images, social links, and outbound link-in-bio URLs for lead generation and monitoring.

- **URL**: https://apify.com/automation-lab/linktree-profile-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Linktree Profile Scraper

Extract public Linktree profile metadata, social links, and link-in-bio destinations from usernames or profile URLs.

### What does Linktree Profile Scraper do?

Linktree Profile Scraper turns public Linktree pages into structured data that is ready for exports, enrichment, lead lists, creator research, and monitoring workflows.

It reads public profile HTML and extracts profile metadata, bio text, images, social links, the significant link, and visible outbound Linktree buttons.

The actor is HTTP-only, fast, and designed for small discovery jobs as well as larger profile lists.

### Who is it for?

- 🧲 **Lead generation teams** collecting creator contact and destination links.
- 🧑‍🎤 **Influencer researchers** mapping creators to their websites and social channels.
- 🛍️ **E-commerce analysts** tracking where brands send traffic from link-in-bio pages.
- 📰 **Journalists and researchers** archiving public profile metadata.
- 🧪 **Growth teams** monitoring changes to campaign landing links.
- 🧰 **Data teams** enriching existing social profile lists with outbound URLs.

### Why use this actor?

- 🌳 Accepts Linktree usernames or full profile URLs.
- 🔗 Extracts social links and public outbound link buttons.
- 🖼️ Captures avatar and Open Graph image URLs.
- 🕒 Includes created/modified timestamps when Linktree exposes them.
- 📦 Produces a clean dataset item per profile.
- ⚡ Uses HTTP extraction, so runs are lightweight and cost-efficient.

### What data can you extract?

| Field | Description |
|---|---|
| `username` | Linktree username / handle |
| `url` | Normalized Linktree profile URL |
| `canonicalUrl` | Canonical URL from the page |
| `title` | Open Graph or profile title |
| `displayName` | Linktree display/page name |
| `bio` | Public profile description |
| `avatarUrl` | Profile image URL when available |
| `ogImageUrl` | Open Graph image URL |
| `dateCreated` | Profile creation timestamp when exposed |
| `dateModified` | Last modified timestamp when exposed |
| `significantLink` | Significant link from JSON-LD |
| `sameAs` | Social URLs from JSON-LD |
| `socialLinks` | Normalized social platform links |
| `links` | Visible Linktree button links with titles and positions |
| `linkCount` | Number of extracted public buttons |
| `socialLinkCount` | Number of social links |
| `scrapedAt` | Time the actor scraped the profile |

### How much does it cost to scrape Linktree profiles?

This actor uses pay-per-event pricing.

You pay a small start fee for the run and a per-profile fee for each profile saved to the dataset.

The input prefill is intentionally small so your first run is cheap.

Final platform pricing is shown on the Apify Store pricing tab and in the run charge summary.

### Input

You can provide profile URLs, usernames, or both.

```json
{
  "profileUrls": [
    { "url": "https://linktr.ee/apify" },
    { "url": "https://linktr.ee/linktree" }
  ],
  "usernames": ["apify"],
  "maxProfiles": 3,
  "includeRawData": false
}
````

### Input fields

#### `profileUrls`

Array of public Linktree profile URLs.

Use this when you already have URLs from another source.

#### `usernames`

Array of Linktree usernames.

The actor accepts usernames with or without `@`.

#### `maxProfiles`

Maximum number of unique profiles to process.

Duplicate usernames are removed before scraping.

#### `includeRawData`

When enabled, the output includes parsed JSON-LD blocks as `rawJsonLd`.

Use it for debugging or custom downstream parsing.

### Output example

```json
{
  "username": "apify",
  "url": "https://linktr.ee/apify",
  "title": "apify Official: Instagram, X | Linktree",
  "bio": "Public profile description...",
  "avatarUrl": "https://ugc.production.linktr.ee/...jpeg",
  "significantLink": "https://wa.me/85295804891",
  "sameAs": ["https://instagram.com/apify_official"],
  "socialLinks": [
    { "platform": "Instagram", "url": "https://instagram.com/apify_official" }
  ],
  "links": [
    { "title": "WhatsApp", "url": "https://wa.me/85295804891", "position": 1 }
  ],
  "linkCount": 1,
  "socialLinkCount": 4,
  "scrapedAt": "2026-05-30T00:00:00.000Z"
}
```

### How to scrape Linktree profiles

1. Open the actor on Apify.
2. Paste Linktree profile URLs or usernames.
3. Set a small `maxProfiles` value for a test run.
4. Start the actor.
5. Export the dataset as JSON, CSV, Excel, or via API.

### Tips for better results

- Use public Linktree profile URLs only.
- Keep the first run small to validate your inputs.
- Use usernames when URLs come from messy spreadsheets.
- Enable `includeRawData` only if you need JSON-LD diagnostics.
- Run recurring jobs if you need link-in-bio monitoring.

### Common use cases

#### Creator lead enrichment

Start with a list of Linktree usernames and export profile bios, websites, and social links.

#### Brand monitoring

Track which outbound campaign links a creator or brand currently promotes.

#### Social graph building

Combine Linktree `sameAs` links with social network scrapers to build broader creator profiles.

#### Link-in-bio audits

Check whether profiles route traffic to expected stores, forms, or landing pages.

### Integrations

Use the dataset with:

- Google Sheets exports for sales teams.
- CRM imports for enrichment workflows.
- Apify webhooks for recurring monitoring.
- Data warehouses through Apify API integrations.
- Social scrapers for follow-up enrichment.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/linktree-profile-scraper').call({
  usernames: ['apify'],
  maxProfiles: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/linktree-profile-scraper').call(run_input={
    'usernames': ['apify'],
    'maxProfiles': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~linktree-profile-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"usernames":["apify"],"maxProfiles":1}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP Server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/linktree-profile-scraper
```

Claude Code setup:

```bash
claude mcp add apify-linktree "https://mcp.apify.com/?tools=automation-lab/linktree-profile-scraper"
```

JSON MCP configuration:

```json
{
  "mcpServers": {
    "apify-linktree": {
      "url": "https://mcp.apify.com/?tools=automation-lab/linktree-profile-scraper"
    }
  }
}
```

Example prompts:

- "Scrape these Linktree usernames and return their outbound links."
- "Find the social links on this Linktree profile."
- "Monitor this Linktree profile and tell me when the significant link changes."

### Data quality notes

Linktree exposes different fields depending on the profile configuration.

Some profiles have many visible buttons, while others expose only social links or metadata.

The actor skips missing profiles and continues with the rest of the input list.

### Limitations

- Private, deleted, suspended, or non-existent profiles cannot be scraped.
- Some links may be hidden by Linktree or rendered conditionally.
- The actor extracts public page data only; it does not log in or bypass access controls.

### Legality

This actor extracts publicly available information from public Linktree pages.

You are responsible for using the data lawfully and respecting applicable privacy, data protection, and platform rules.

Avoid scraping personal data unless you have a lawful basis and a clear use case.

### FAQ

#### Can I scrape private Linktree profiles?

No. This actor only extracts data from public Linktree profile pages.

#### Does the actor follow every outbound link?

No. It extracts the public destinations listed on the Linktree page; it does not crawl destination websites.

### Troubleshooting

#### Why did I get fewer profiles than requested?

The actor removes duplicate usernames and skips profiles that return errors such as 404.

#### Why are some link titles missing?

Some Linktree links may expose a destination URL but no clean title in the page data.

#### Why is `rawJsonLd` missing?

Set `includeRawData` to `true` if you want parsed JSON-LD blocks in the output.

### Related scrapers

- https://apify.com/automation-lab/instagram-profile-scraper
- https://apify.com/automation-lab/tiktok-profile-scraper
- https://apify.com/automation-lab/social-media-leads-analyzer
- https://apify.com/automation-lab/web-contact-scraper

### Changelog

#### 0.1

Initial version with public Linktree profile metadata, social links, outbound links, and JSON-LD extraction.

### Support

If you need a field that is visible on public Linktree pages but missing from the dataset, open an issue on the actor page with an example profile URL.

# Actor input Schema

## `profileUrls` (type: `array`):

Public Linktree profile URLs to scrape. You can also use the usernames field below.

## `usernames` (type: `array`):

Optional Linktree usernames, with or without @. Example: apify

## `maxProfiles` (type: `integer`):

Maximum number of unique Linktree profiles to process in this run.

## `includeRawData` (type: `boolean`):

Include the parsed JSON-LD blocks from the page for debugging or custom downstream processing.

## Actor input object example

```json
{
  "profileUrls": [
    {
      "url": "https://linktr.ee/apify"
    },
    {
      "url": "https://linktr.ee/linktree"
    }
  ],
  "usernames": [
    "apify"
  ],
  "maxProfiles": 3,
  "includeRawData": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "profileUrls": [
        {
            "url": "https://linktr.ee/apify"
        },
        {
            "url": "https://linktr.ee/linktree"
        }
    ],
    "usernames": [
        "apify"
    ],
    "maxProfiles": 3,
    "includeRawData": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/linktree-profile-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 = {
    "profileUrls": [
        { "url": "https://linktr.ee/apify" },
        { "url": "https://linktr.ee/linktree" },
    ],
    "usernames": ["apify"],
    "maxProfiles": 3,
    "includeRawData": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/linktree-profile-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 '{
  "profileUrls": [
    {
      "url": "https://linktr.ee/apify"
    },
    {
      "url": "https://linktr.ee/linktree"
    }
  ],
  "usernames": [
    "apify"
  ],
  "maxProfiles": 3,
  "includeRawData": false
}' |
apify call automation-lab/linktree-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linktree Profile Scraper",
        "description": "Extract public Linktree profile bios, images, social links, and outbound link-in-bio URLs for lead generation and monitoring.",
        "version": "0.1",
        "x-build-id": "bdvSDuDrEd2COGCEP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~linktree-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-linktree-profile-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/automation-lab~linktree-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-linktree-profile-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/automation-lab~linktree-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-linktree-profile-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": {
                    "profileUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "Public Linktree profile URLs to scrape. You can also use the usernames field below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Optional Linktree usernames, with or without @. Example: apify",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProfiles": {
                        "title": "Maximum profiles",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique Linktree profiles to process in this run.",
                        "default": 25
                    },
                    "includeRawData": {
                        "title": "Include raw JSON-LD",
                        "type": "boolean",
                        "description": "Include the parsed JSON-LD blocks from the page for debugging or custom downstream processing.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```