# Linktree Profile & Links Scraper (`datascraperes/linktree-profile-scraper`) Actor

Extract complete public Linktree profiles in structured JSON. Get bios, avatars, verification, themes, social links, pinned links, every outbound link, and detected video links from usernames or profile URLs. Useful for creator research, link-in-bio analysis, and competitor monitoring.

- **URL**: https://apify.com/datascraperes/linktree-profile-scraper.md
- **Developed by:** [DataScraperES](https://apify.com/datascraperes) (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

$1.00 / 1,000 profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 & Links Scraper

Extract complete public Linktree profile data into a structured dataset. Enter
Linktree usernames or full profile URLs and receive one profile record with the
identity, bio, avatar, verification status, page theme, social links, pinned
links, and every public link displayed on the profile.

The Actor also creates a convenient `videoLinks` view for public video URLs
found among the profile links. Videos and links remain part of the same profile
record, giving you a complete view of a Linktree page without separate charges
for individual links or videos.

### What can this Linktree scraper do?

- Collect one or many public Linktree profiles in a single run.
- Accept usernames, `@usernames`, or full `https://linktr.ee/<username>` URLs.
- Remove duplicate profile references automatically.
- Return one structured dataset item for every profile obtained successfully.
- Preserve the complete ordered link collection, including links inside groups.
- Identify typed social destinations such as Instagram, TikTok, YouTube,
  Spotify, X, and other platforms published by the profile.
- Detect public video URLs from supported video platforms and include their
  title, type, source link, and position.
- Include page metadata and visibility signals that help with profile analysis.
- Export results from Apify in JSON, CSV, Excel, and other supported formats.

### What data is extracted?

The Actor collects information that is publicly available on the Linktree
profile page. It does not invent values when a profile does not publish a
field; unavailable values are returned as `null` or an empty list.

#### Profile information

| Field | Description |
| --- | --- |
| `profileUrl` | Canonical Linktree URL that was collected. |
| `finalUrl` | Final URL after any normal page redirect, when available. |
| `slug` | Username segment used in the profile URL. |
| `username` | Username displayed or identified on the profile. |
| `pageTitle` | Public profile title or display name. |
| `description` | Public profile bio or description. |
| `avatarUrl` | Public profile image URL, when available. |
| `verified` | Whether the public profile is marked as verified. |
| `metaTitle` | Public page metadata title, when available. |
| `metaDescription` | Public page metadata description, when available. |
| `theme` | Public theme information such as background, button style, social style, and typeface. |

#### Page and visibility signals

| Field | Description |
| --- | --- |
| `hasPagePassword` | Whether the profile indicates that a page password is required. |
| `hasUnlockedProfile` | Whether the profile indicates that its gated content has been unlocked. |
| `contentGating` | Public content-gating signal, when present. |
| `shouldNoIndex` | Whether the profile publicly marks the page as not intended for indexing. |
| `warnings` | Public result warnings, such as a locked or sensitive profile. |

#### Links and social links

The `links` array contains the complete public link collection in display order.
Depending on what Linktree publishes, each link can include:

- `id`: Linktree link identifier.
- `title`: Visible link title.
- `context`: Additional visible link context, when available.
- `url`: Destination URL, including regular URLs and public `mailto:` or `tel:` links.
- `type`: Linktree link type.
- `position`: Display position.
- `locked`: Whether the individual link is marked as locked.
- `layoutOption`, `itemStyle`: Public presentation options, when available.
- `children`: Nested links inside a group, when available.
- `thumbnail`: Link image URL when **Include thumbnail URLs** is enabled.

The `pinnedLinks` array contains publicly pinned links when the profile
provides them. The `socialLinks` array contains typed social destinations with
their `url`, `service`, and `title` values when available.

#### Public email addresses

The `emails` array contains unique email addresses explicitly exposed by the
public profile. It can include addresses from public `mailto:` links, visible
structured email fields, or the profile description. `emailsCount` contains the
number of detected addresses. If no public email is available, the Actor
returns an empty array. The Actor does not search private content or infer
addresses from hidden data.

#### Video links

`videoLinks` is a filtered view of video URLs already present in the profile's
public `links` collection. Each detected video link can include:

- `videoUrl`
- `videoTitle`
- `videoType`
- `sourceLinkId`
- `sourcePosition`
- `profileUrl`
- `username`
- `capturedAt`

The Actor returns video URLs; it does not download or host video files.

#### Result information

| Field | Description |
| --- | --- |
| `recordType` | Identifies the dataset item as a `profile` record. |
| `ok` | `true` when a complete public profile was obtained. |
| `status` | Result state, such as `ok`, `locked`, `not_found`, or `blocked`. |
| `linksCount` | Number of public links returned. |
| `socialLinksCount` | Number of social links returned. |
| `emailsCount` | Number of unique public email addresses detected. |
| `videoCount` | Number of unique public video links found in the profile. |
| `httpStatus` | HTTP response status, when available. |
| `requestAttempts` | Number of collection attempts used for the profile. |
| `capturedAt` | UTC timestamp for the collected profile record. |

### Who is this Actor for?

- **Creator and influencer research:** review the destinations promoted by a
  creator and the social platforms they publish.
- **Link-in-bio analysis:** build a structured view of how profiles organize
  their websites, stores, campaigns, and content.
- **Competitor monitoring:** compare public profile descriptions, themes, link
  order, pinned destinations, and social presence over time.
- **Brand and agency research:** collect public profiles for discovery,
  enrichment, and campaign planning.
- **Dataset building:** create clean profile and outbound-link datasets for
  spreadsheets, reporting, and analytics.

### How to use it in Apify

1. Open the Actor and go to the **Input** tab.
2. Add usernames or full Linktree profile URLs in **Profiles or usernames**.
3. Optionally enable **Include thumbnail URLs** when you also want public link
   thumbnail URLs in the result.
4. Click **Start** and open the **Dataset** tab when the run finishes.

The input accepts all of these formats:

```text
linktree
@linktree
https://linktr.ee/linktree
```

The Actor accepts up to 500 input references per run. Duplicate references are
processed only once.

### Input options

| Field | Required | Default | Description |
| --- | --- | --- | --- |
| `profiles` | Yes | `linktree` | Usernames or full Linktree profile URLs. Up to 500 entries. |
| `includeImages` | No | `false` | Adds public thumbnail URLs to link objects when available. |

For the first run, the following input is sufficient:

```json
{
  "profiles": ["linktree", "https://linktr.ee/i_blade"]
}
```

### Example output

Each successfully obtained profile is written as one dataset item:

```json
{
  "recordType": "profile",
  "ok": true,
  "status": "ok",
  "profileUrl": "https://linktr.ee/example",
  "finalUrl": "https://linktr.ee/example",
  "slug": "example",
  "username": "example",
  "pageTitle": "Example profile",
  "description": "Public profile description",
  "metaTitle": "Example profile",
  "metaDescription": "Public profile description",
  "avatarUrl": "https://...",
  "verified": true,
  "hasPagePassword": false,
  "hasUnlockedProfile": true,
  "shouldNoIndex": false,
  "theme": {
    "key": "minimal",
    "background": "#ffffff",
    "buttonStyle": "rounded"
  },
  "links": [
    {
      "id": "123",
      "title": "Website",
      "url": "https://example.com",
      "type": "CLASSIC",
      "position": 1,
      "locked": false
    }
  ],
  "pinnedLinks": [],
  "socialLinks": [
    {
      "service": "INSTAGRAM",
      "url": "https://instagram.com/example"
    }
  ],
  "linksCount": 1,
  "socialLinksCount": 1,
  "emails": ["contact@example.com"],
  "emailsCount": 1,
  "videoCount": 0,
  "videoLinks": [],
  "warnings": [],
  "capturedAt": "2026-08-18T00:00:00+00:00"
}
```

### Pricing

The Actor costs **$0.001 per successfully obtained profile**, equivalent to
**$1 per 1,000 profiles**.

- One complete profile record equals one charged profile.
- Links, social links, and video URLs are included in that profile record.
- Individual links and videos are not charged separately.
- Invalid, locked, unavailable, or blocked profiles are not charged as
  successful profile results.
- Set a maximum run charge in Apify when you want an additional spending limit.

Apify may display standard platform resource costs separately according to your
account plan. The Actor charge itself is based on successfully obtained profile
records.

### Understanding incomplete results

Some profiles may not produce a complete dataset record:

- `locked`: the profile or its content requires a password or unlock action.
- `not_found`: the profile is removed or the URL does not identify a profile.
- `paused`: the target temporarily refuses the request.
- `blocked` or `rate_limited`: the page cannot be collected at that time.
- `invalid_input`: the value is not a valid Linktree username or profile URL.

These outcomes do not create a successful profile result. Check the input
format and retry later when a public profile is temporarily unavailable.

### Frequently asked questions

#### Does it collect the complete Linktree profile?

It collects the public profile information exposed by the page: identity,
description, avatar, verification, theme, social links, pinned links, the full
public link collection, page metadata, and public video links. Information that
Linktree does not publish is not available to the Actor.

#### Does it scrape videos?

It identifies public video URLs included in profile links and returns them in
`videoLinks`. It does not download the video files, extract video captions, or
collect private video analytics.

#### Does it collect private or password-protected profiles?

No. The Actor is limited to publicly available profile information and does not
bypass passwords, private access, login pages, or other access controls.

#### Why is a field empty?

The profile may not publish that information, or the field may not be available
for that profile type. Empty fields are returned as `null` or empty arrays
instead of being guessed.

#### Why is a profile missing from the Dataset?

Only successfully obtained profiles are written as dataset records. Invalid,
locked, removed, or temporarily unavailable inputs may be reported in the run
result without producing a successful profile row.

#### Are duplicate profiles charged twice?

No. Duplicate usernames and URLs are normalized and processed only once within
the same run.

#### Can I include thumbnail images?

Yes. Enable **Include thumbnail URLs** in the input. When Linktree provides a
thumbnail for a public link, its URL is included in that link object.

### Responsible use

Use this Actor only for public profiles and collection purposes you are allowed
to access. You are responsible for complying with Linktree's terms, applicable
privacy and data-protection laws, and any rules that apply to the data you
collect or store.

# Actor input Schema

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

Enter Linktree usernames or full https://linktr.ee/<username> profile URLs. Duplicate entries are removed.

## `includeImages` (type: `boolean`):

Include link thumbnail/image URLs when available.

## Actor input object example

```json
{
  "profiles": [
    "linktree"
  ],
  "includeImages": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runStats` (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 = {
    "profiles": [
        "linktree"
    ],
    "includeImages": false
};

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

# Run the Actor and wait for it to finish
run = client.actor("datascraperes/linktree-profile-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "linktree"
  ],
  "includeImages": false
}' |
apify call datascraperes/linktree-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datascraperes/linktree-profile-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gwdbbngIBRR1s7wxL/builds/YGslIJ01fsHlFGX28/openapi.json