# Linktree Scraper: Find Profiles by Sector & Keyword (`runtime/linktree-scraper`) Actor

Find Linktree profiles by sector (fashion, weddings, real estate, 100+ sections) and get bios, social links, websites, public emails and phones. No login needed.

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

## Pricing

from $3.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Linktree Scraper: Find Profiles by Sector & Keyword

> **中文简介 / Chinese summary**
>
> - **功能：** 按行业（时尚品牌、快闪店、婚礼、房地产等 100 多个分类）从 Linktree 官方目录发现个人主页，并提取简介、链接、社交账号、网站、公开邮箱和电话，可用于品牌线索挖掘和市场调研。
> - **输入示例：** `{"sectors":["fashion-brands"],"onlyBrands":true,"maxProfiles":50}`
> - **计费：** 按结果付费（pay-per-result），价格见本页 **Pricing** 标签；可设置单次运行最大费用以控制支出。
> - **支持：** 遇到问题请在 **Issues** 标签提交，并附上输入参数和 Run ID。

Find Linktree (`linktr.ee`) profiles for any industry, then collect what each one publishes: bio, links, social accounts, websites, public emails and phone numbers. Pick a sector (fashion, fitness, food, travel...), add your own keywords and cities, and get a list of matching profiles. No login, no browser, no API key.

### How discovery works

Linktree has no search box, but it publishes an official **profile directory** organised by sector (`linktr.ee/discover/profile-directory`): 12 categories and about 95 sub-sectors, with thousands of profiles each. The Actor reads it directly:

1. **Directory** (main source): pick sector bundles or exact directory sections (fashion and beauty, weddings, real estate, nail care, bars and restaurants...). The Actor walks the pages of each section, about 20 profiles per page. Profiles found this way are already in their sector, so none is thrown away on a keyword check.
2. **Web search** (for custom keywords and cities): the directory cannot be filtered by city or niche term, so for those the Actor runs `site:linktr.ee "keyword" "city"` searches and keeps only profiles whose Linktree category, bio, title or link titles match.
3. **Extract**: every candidate profile is opened and its bio, links, socials, emails and phones are saved.
4. **Optional**: it can also follow the ~45 related profiles Linktree lists on each page.

### What you get

One dataset item per profile:

- `username`, `url`, `name`, `description` (bio), `isVerified`, `country`
- `sectors` (which of your sectors it matched) and `verticals` (Linktree's own category tags)
- `likelyBrand` and `brandSignals`: a heuristic that separates businesses (own website, business email, store platform) from individual creators
- `emails` and `phones` found in the bio, `mailto:`, `tel:` and WhatsApp links
- `socialProfiles` (Instagram, TikTok, YouTube, X, LinkedIn, Facebook and more) and `websites` (unique site origins)
- `links` (title, URL and type of every link, up to 50), `linkCount`
- `createdAt`, `updatedAt`, `avatarUrl`
- `discoveredVia` (`search`, `related` or `input`) and the `query` that found it

Turn off **Scrape profile details** to get only the profile URLs (username, URL, sector, query) at a lower cost per run.

### Input

- **Sectors**: 14 ready-made bundles, led by **Fashion brands** (clothing, designers, jewelry, shoes, retail from the directory) and **Pop-up stores** (found by web search for pop-up, concept store and showroom bios), then: fashion and beauty, health and wellness, food and drink, travel, music, arts and entertainment, sports, e-commerce, real estate, education and coaching, tech and business, creators and media.
- **Directory sections**: exact categories or sub-sectors of Linktree's directory, such as `s/weddings`, `s/makeup-skincare`, `s/bars-restaurants` or `s/nail-care` (categories start with `c/`, sub-sectors with `s/`). Combine freely with the bundles.
- **Directory start page**: skip the pages you already collected to get new profiles on the next run.
- **Custom keywords** and **cities**: niche terms such as `wedding photographer` or `vegan bakery`, found through web search (use a proxy).
- **Known profiles**: Linktree URLs or usernames to scrape directly.
- **Max profiles**, **only these countries** (ISO codes from the profile settings), **only profiles with a public email**, **only brands and businesses**, **exclude adult content** (on by default).
- **Also follow related profiles**: off by default; related profiles are often off-topic, so most get filtered out.
- **Proxy**: recommended for keyword and city search, because the search engine rate-limits repeated queries from one IP. Directory discovery works without one.

### Example

```json
{
    "directorySections": ["s/weddings", "s/makeup-skincare"],
    "countries": ["FR"],
    "maxProfiles": 100,
    "onlyWithEmail": true,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### Use it from automations and AI agents

Run it from the Apify API, Make, Zapier, n8n, schedules or webhooks, and read the results from the dataset. You can also call it from AI assistants through the [Apify MCP server](https://mcp.apify.com): add this Actor to your MCP client (Claude, Cursor, VS Code and others) and ask in plain language, for example "find 50 French fashion brands on Linktree with a public email".

### Pricing

Pay per result: you are charged for each profile saved to the dataset, plus a tiny start fee. Profiles that are filtered out are not charged. Set a maximum cost per run in the Apify run options to cap spending.

### Good to know

- Only public information is collected: what a Linktree page shows to any visitor. Emails and phones appear only when the owner published them.
- The directory is paginated (about 20 profiles per page) and the Actor pages through it automatically. With strict filters it keeps reading pages until it has **Max profiles** matches or reaches **Max profiles to scan**, then finishes with what it found.
- The directory has no location filter, and the **Only these countries** filter has a low yield because most profiles do not declare a country (in our tests about 1 profile in 100 passed a FR filter on fashion sections). To target a city or country, prefer **Cities** with a sector or keyword: that goes through web search, which understands places in bios.
- Directory sizes vary a lot: about 930 pages for fashion and beauty, 43 for weddings, 3 for libraries. A section that runs out simply stops.
- Keyword search returns about 25 profiles per result page and deeper pages mostly repeat, so large keyword lists come from many keyword and city combinations rather than from paging.
- Bios in other languages need keywords in that language when you use keyword search.
- `likelyBrand` is a heuristic from the profile's links, not a Linktree label: a creator with a personal website counts as a brand, and a small shop with only social links does not. Use it to prioritise, not as a guarantee.
- Check that your use of the data complies with privacy and marketing rules in your country (GDPR, CAN-SPAM), especially for personal emails.

# Actor input Schema

## `sectors` (type: `array`):

Ready-made sector bundles. Most read Linktree's official profile directory; Pop-up stores has no directory section, so it uses web search (a proxy is recommended).

## `directorySections` (type: `array`):

Pick exact sections of Linktree's profile directory: 12 categories and ~95 sub-sectors such as weddings, real estate, makeup & skincare, bars & restaurants or nail care. About 20 profiles per page. Can be combined with the sector bundles.

## `directoryStartPage` (type: `integer`):

First directory page to read in each section. Raise it to get new profiles on later runs (each page holds ~20 profiles).

## `keywords` (type: `array`):

Your own niche terms, one per line, e.g. wedding photographer, vegan bakery, crossfit coach. These are found through web search (Linktree has no search), then each profile must contain the term in its bio, title or link titles.

## `locations` (type: `array`):

Optional places for the keyword search, e.g. Paris, Lyon, Brazil (adds web-search queries; the directory itself has no location). To keep only one country use the country filter below.

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

Linktree URLs or usernames to scrape directly, e.g. https://linktr.ee/selenagomez. Also used as starting points when related profiles are followed.

## `scrapeProfiles` (type: `boolean`):

On: open every profile and extract bio, links, socials, emails, phones. Off: only return the discovered profile URLs (fastest, no sector verification).

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

Maximum profiles saved to the dataset.

## `maxProfilesToScan` (type: `integer`):

Safety limit on how many profiles are opened while looking for matches. Strict filters (country, email) reject most profiles, so the Actor keeps reading directory pages until it has enough matches or reaches this limit. Default: 25x Max profiles, between 300 and 5000.

## `requireSectorMatch` (type: `boolean`):

For profiles found by web search: drop those whose Linktree category, bio, title or link titles do not match your sector or keyword. Directory profiles are already in their section.

## `countries` (type: `array`):

Optional ISO country codes from the profile settings, e.g. FR, US, BR. Most profiles do not declare a country, so this filter rejects most profiles and raises the scan needed (for a city or country, prefer the Cities field). Profiles without a country are dropped.

## `onlyWithEmail` (type: `boolean`):

Keep profiles that publish an email address in their bio or a mailto link.

## `onlyBrands` (type: `boolean`):

Keep profiles that look like a business rather than an individual creator: an own website, a business email or a store platform (Shopify, Etsy...). This is a heuristic based on the profile's links, not a Linktree label.

## `excludeAdult` (type: `boolean`):

Skip profiles flagged sensitive or linking to adult subscription sites.

## `expandRelated` (type: `boolean`):

Open the ~45 profiles Linktree lists as related on each page. Related profiles are often off-topic, so most are filtered out; costs more requests.

## `maxExpansionDepth` (type: `integer`):

How many hops of related profiles to follow.

## `keywordsPerSector` (type: `integer`):

How many keywords of each sector preset are searched. More keywords find more profiles but take longer.

## `maxQueries` (type: `integer`):

Hard cap on search queries (sector keywords x locations).

## `searchPagesPerQuery` (type: `integer`):

Each page returns up to ~25 profiles; deeper pages mostly repeat.

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

Recommended for keyword and city search: the search engine rate-limits repeated queries from one IP. Directory discovery works without it.

## Actor input object example

```json
{
  "sectors": [
    "fashion-brands"
  ],
  "directorySections": [],
  "directoryStartPage": 1,
  "locations": [],
  "scrapeProfiles": true,
  "maxProfiles": 50,
  "requireSectorMatch": true,
  "onlyWithEmail": false,
  "onlyBrands": false,
  "excludeAdult": true,
  "expandRelated": false,
  "maxExpansionDepth": 1,
  "keywordsPerSector": 3,
  "maxQueries": 30,
  "searchPagesPerQuery": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `profiles` (type: `string`):

No description

## `urls` (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 = {
    "sectors": [
        "fashion-brands"
    ],
    "directorySections": [],
    "locations": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("runtime/linktree-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 = {
    "sectors": ["fashion-brands"],
    "directorySections": [],
    "locations": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("runtime/linktree-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 '{
  "sectors": [
    "fashion-brands"
  ],
  "directorySections": [],
  "locations": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call runtime/linktree-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,runtime/linktree-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/hdmrP4jrFa6humg6F/builds/9DPf5LnvMP662MIfj/openapi.json