# Link-in-Bio Contact Leads Scraper (`automation-lab/link-in-bio-contact-leads-scraper`) Actor

Extract public identity, displayed emails and phones, social accounts, bios, and destination links from supplied Linktree and Beacons profiles.

- **URL**: https://apify.com/automation-lab/link-in-bio-contact-leads-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (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

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

## Link-in-Bio Contact Leads Scraper

Turn supplied public Linktree and Beacons profiles into normalized creator-outreach records.
The Actor extracts public identity, bio text, displayed email or phone contacts, social accounts, and outbound destination links.
It does not guess contact details or require a profile login.

Use the same output schema for both supported platforms, so a mixed list can flow directly into a spreadsheet, CRM import, scheduled enrichment job, or data pipeline.

### What does Link-in-Bio Contact Leads Scraper do?

For every valid profile URL, the Actor produces one dataset row containing:

- source platform and normalized profile URL;
- username, display name, bio, and avatar URL;
- email addresses visibly published on the profile;
- phone contacts exposed through public phone links;
- categorized Instagram, TikTok, YouTube, X, Facebook, and other social links;
- other destination links, such as a storefront, newsletter, portfolio, donation page, or website;
- contact and link counts for quick filtering;
- an extraction timestamp.

Linktree pages use a lightweight structured-HTML route.
Beacons pages use browser rendering because their public pages can reject ordinary HTTP clients.
The browser starts only when a run includes a Beacons URL.

### Who is this link-in-bio scraper for?

This Actor is useful for:

- creator partnership teams enriching an approved prospect list;
- influencer marketing agencies consolidating public contact channels;
- sales operations teams preparing creator outreach imports;
- researchers mapping public cross-platform identities;
- brand teams reviewing destinations linked from creator profiles;
- developers normalizing Linktree and Beacons records through one API;
- analysts tracking changes with separate scheduled dataset runs.

It is a URL-list enrichment tool, not a creator discovery search engine.
Supply the profiles you are authorized to process.

### Why use this Actor?

A creator may put contact details and key destinations on a link-in-bio page rather than on the original social profile.
Checking those pages manually is slow and produces inconsistent columns.

This Actor provides:

1. **Two popular sources in one contract** — Linktree and Beacons records share field names.
2. **Public contacts only** — email and phone values come from visible page content or public contact links.
3. **Useful link classification** — social accounts are separated from other destinations.
4. **Mixed-list support** — process Linktree and Beacons URLs in the same run.
5. **Bounded inputs** — duplicate profiles are removed and each run accepts up to 100 unique profiles.
6. **Integration-ready output** — use the default dataset with API, CSV, Excel, webhooks, or Apify integrations.

### What data can you extract?

| Field | Type | Meaning |
| --- | --- | --- |
| `inputUrl` | string | Original URL supplied in the input |
| `profileUrl` | string | Normalized public profile URL |
| `platform` | string | `Linktree` or `Beacons` |
| `username` | string | Username from the profile path |
| `displayName` | string or null | Public profile or creator name |
| `bio` | string or null | Public profile description |
| `avatarUrl` | string or null | Public profile image URL |
| `emails` | string\[] | Email addresses displayed on the page |
| `emailCount` | integer | Number of unique displayed emails |
| `phones` | string\[] | Values from public `tel:` contact links |
| `socialLinks` | object\[] | Categorized social profile links |
| `destinationLinks` | object\[] | Non-social outbound links and labels |
| `linkCount` | integer | Unique social plus destination links |
| `hasContact` | boolean | Whether a displayed email or phone was found |
| `scrapedAt` | string | ISO 8601 extraction time |

Each link object contains its resolved `url` and visible `title` when available.
Social link objects also contain `platform`.

### How to scrape Linktree and Beacons profiles

1. Open the Actor input page.
2. Add one or more public `linktr.ee` or `beacons.ai` profile URLs.
3. Set **Maximum profiles** to the output limit you need.
4. Click **Start**.
5. Open the default dataset when the run succeeds.
6. Export JSON, CSV, Excel, XML, or another supported dataset format.

A first test can use the prefilled profiles:

```json
{
  "startUrls": [
    { "url": "https://linktr.ee/thefashionsessions" },
    { "url": "https://beacons.ai/1minuteanimals" }
  ],
  "maxItems": 2
}
```

### Input parameters

#### `startUrls`

Required array of public Linktree or Beacons profile URLs.
The Actor accepts full `https://linktr.ee/<username>` and `https://beacons.ai/<username>` URLs.
Query strings and fragments are removed during normalization.
Duplicate URLs are processed once.

Unsupported domains, malformed URLs, and URLs without a profile username fail input validation.
This fail-closed behavior prevents a successful but misleading empty dataset.

#### `maxItems`

Optional integer from 1 to 100.
The default is 25.
The Actor stops after this many unique profile inputs.

`maxItems` does not discover additional profiles and does not silently change source scope.

### Output example

A current Beacons profile produces a row shaped like this:

```json
{
  "inputUrl": "https://beacons.ai/1minuteanimals",
  "profileUrl": "https://beacons.ai/1minuteanimals",
  "platform": "Beacons",
  "username": "1minuteanimals",
  "displayName": "1minuteanimals",
  "bio": null,
  "avatarUrl": "https://cdn.beacons.ai/...",
  "emails": [],
  "emailCount": 0,
  "phones": [],
  "socialLinks": [
    {
      "platform": "YouTube",
      "title": "Youtube 1 Minute Animals",
      "url": "https://www.youtube.com/c/AnimalPlanetVideos_?sub_confirmation=1"
    },
    {
      "platform": "Instagram",
      "title": "Instagram 1 Minute Animals",
      "url": "https://www.instagram.com/1minuteanimal/"
    }
  ],
  "destinationLinks": [
    {
      "title": "Buy Me A Coffee",
      "url": "https://www.buymeacoffee.com/1minuteanimals"
    }
  ],
  "linkCount": 9,
  "hasContact": false,
  "scrapedAt": "2026-08-11T14:09:00.000Z"
}
```

The example abbreviates the avatar URL and link arrays for readability.
Actual dataset rows contain all extracted fields.
A profile is still useful when `emails` is empty: its identity, social accounts, and destinations remain available.

### How much does it cost to extract link-in-bio contact leads?

Pricing uses one `start` event per run plus one `item` event per saved dataset row.
Email addresses, phones, and individual links do not create separate charges.

The current start price is **$0.005 per run**.
The BRONZE profile price is **$0.0032 per saved profile**, with lower per-profile rates at higher platform tiers.

Examples at the BRONZE item rate:

| Saved profiles | Start | `item` events | Estimated total |
| ---: | ---: | ---: | ---: |
| 1 | $0.005 | $0.0032 | $0.0082 |
| 10 | $0.005 | $0.0320 | $0.0370 |
| 25 | $0.005 | $0.0800 | $0.0850 |
| 100 | $0.005 | $0.3200 | $0.3250 |

The active tier attached to your Apify account determines the exact per-profile price.
Only saved profile records trigger the `item` charge.
Invalid input fails before profile extraction.

### Creator outreach enrichment workflow

A practical recurring workflow is:

1. Keep an approved list of creator Linktree and Beacons URLs in a table.
2. Run the Actor on a schedule with that URL list.
3. Export the new default dataset to Google Sheets, Airtable, or your warehouse.
4. Match rows by `profileUrl`.
5. Compare `emails`, `socialLinks`, and `destinationLinks` with the previous run.
6. Review changes before updating a CRM or contacting a creator.

The Actor creates current snapshots.
It does not itself compare runs, send outreach, monitor continuously, or mutate your CRM.
Apify schedules, webhooks, and integrations can connect those steps.

### Spreadsheet and data-pipeline integrations

Use Apify integrations to send the default dataset to:

- Google Sheets for list review;
- Airtable for outreach operations;
- Make or Zapier for workflow automation;
- Slack for internal run notifications;
- a webhook endpoint after a run finishes;
- a data warehouse through the Dataset API.

Filter `hasContact = true` when a workflow specifically needs a displayed email or phone.
Keep rows with `hasContact = false` when social identity and linked destinations are still useful.

### Run with the Apify API

Replace `YOUR_TOKEN` with your Apify API token.
Do not place tokens in source control.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~link-in-bio-contact-leads-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      {"url": "https://linktr.ee/thefashionsessions"},
      {"url": "https://beacons.ai/1minuteanimals"}
    ],
    "maxItems": 2
  }'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/link-in-bio-contact-leads-scraper').call({
    startUrls: [
        { url: 'https://linktr.ee/thefashionsessions' },
        { url: 'https://beacons.ai/1minuteanimals' },
    ],
    maxItems: 2,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/link-in-bio-contact-leads-scraper").call(run_input={
    "startUrls": [
        {"url": "https://linktr.ee/thefashionsessions"},
        {"url": "https://beacons.ai/1minuteanimals"},
    ],
    "maxItems": 2,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Use with Model Context Protocol (MCP)

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/link-in-bio-contact-leads-scraper"
```

The same endpoint works in **Claude Desktop**, **Cursor**, and **VS Code** MCP settings.
Add an HTTP MCP server named `apify` in any of those clients with the following configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/link-in-bio-contact-leads-scraper"
    }
  }
}
```

Example prompts:

- “Extract the public contact and social links from these Linktree URLs.”
- “Normalize these Linktree and Beacons profiles into creator lead rows.”
- “Return only rows that expose a displayed email or phone.”
- “Summarize the storefront and social destinations on these profiles.”

The MCP client still needs authorization to run the Actor in your Apify account.

### Reliability and retry behavior

Linktree requests use bounded retries for temporary network, rate-limit, and server failures.
Permanent invalid-profile responses are not retried blindly.

Beacons extraction uses a browser session because normal requests may receive a Cloudflare block page.
A challenged or transiently failed profile receives one retry in a fresh browser context.
If useful page content still cannot be loaded, the run fails with a diagnostic error rather than saving an empty record.

One browser is reused across Beacons profiles to reduce startup cost, while contexts isolate profile sessions.

### Limits and expected behavior

- Supported sources are `linktr.ee` and `beacons.ai` public profile pages.
- A run accepts at most 100 input URLs and saves at most 100 records.
- The Actor does not search Linktree or Beacons directories.
- The Actor does not log in or access private profile data.
- The Actor does not follow outbound websites to discover hidden contacts.
- Email and phone coverage depends on what the profile owner publicly displays.
- Links loaded only after unsupported user interaction may be absent.
- Source layout and anti-bot changes can temporarily affect extraction.
- Deleted or unavailable profiles cause an explicit failure.
- A full video link in profile bio is preserved as a destination or social URL; the Actor does not download the video.

### Responsible use and legality

Only process data you are authorized to collect and use.
Public availability does not remove obligations under privacy, marketing, consumer-protection, copyright, or database laws.

Before outreach:

- verify that your purpose and legal basis are appropriate;
- respect opt-outs, suppression lists, and applicable anti-spam rules;
- avoid sensitive-person profiling or discriminatory use;
- minimize retained personal data;
- secure exports and API tokens;
- follow Linktree, Beacons, and linked-platform terms;
- review records before automated contact.

The Actor reports owner-published contact values without claiming that they are verified, current, or intended for every kind of outreach.

### Troubleshooting

#### “Only public Linktree and Beacons profile URLs are supported”

Check that every input is a complete URL on `linktr.ee` or `beacons.ai` and includes a username path.
Social profile URLs and generic websites are not accepted.

#### The run succeeded but `emails` is empty

The profile did not visibly publish a parseable email address at extraction time.
Check `socialLinks` and `destinationLinks`; those fields may still support your research.
The Actor intentionally does not infer an email.

#### A Beacons profile failed after two attempts

The source may have returned an anti-bot challenge, an incomplete page, or a temporary network failure.
Inspect the run log and retry later if the public profile still opens normally.
Do not replace the URL with a private or account-only page.

#### Why are there fewer records than input URLs?

Exact duplicate profile URLs are normalized and processed once.
`maxItems` can also stop the run before every unique URL is processed.

#### Can I supply usernames without URLs?

No.
Full URLs keep source selection explicit and avoid ambiguous usernames across Linktree and Beacons.

### FAQ

#### Does the Actor verify email deliverability?

No.
It extracts email addresses displayed on the public profile.
Use an appropriate verification workflow separately when required and lawful.

#### Does it scrape linked websites for more emails?

No.
Destination links are returned, but the Actor does not crawl those external sites.
This keeps scope, cost, and provenance clear.

#### Can I schedule profile enrichment?

Yes.
Create an Apify schedule with the same input URL list.
Each run creates a current dataset snapshot that your downstream workflow can compare.

#### Are profiles charged when extraction fails?

The one-time `start` event is charged when the run initializes.
The `item` event is charged only for a normalized record that reaches the output path.

#### Does it support custom link-in-bio domains?

Not currently.
The validated contract covers public Linktree and Beacons profile URLs only.

#### Does it download images or videos?

No.
It returns public avatar and destination URLs where available.

### Related Automation Lab Actors

- [Instagram Public Contact Scraper](https://apify.com/automation-lab/instagram-contact-scraper) extracts owner-published contact and profile fields directly from supplied Instagram profiles.
- [TikTok Profile Email Scraper](https://apify.com/automation-lab/tiktok-profile-email-scraper) focuses on publicly displayed TikTok profile email context.
- [Company Domain and Social Links Finder](https://apify.com/automation-lab/company-domain-social-links-finder) maps company websites to public social destinations for a company-oriented workflow.

Choose this Actor when Linktree and Beacons pages are the source of truth and you already have the profile URLs.

# Actor input Schema

## `startUrls` (type: `array`):

Public profile URLs on linktr.ee or beacons.ai. Duplicate URLs are processed once.

## `maxItems` (type: `integer`):

Maximum number of unique profile records to save.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://linktr.ee/thefashionsessions"
    },
    {
      "url": "https://beacons.ai/1minuteanimals"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

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

Open the normalized Linktree and Beacons profile records in the default dataset overview.

# 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 = {
    "startUrls": [
        {
            "url": "https://linktr.ee/thefashionsessions"
        },
        {
            "url": "https://beacons.ai/1minuteanimals"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/link-in-bio-contact-leads-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 = {
    "startUrls": [
        { "url": "https://linktr.ee/thefashionsessions" },
        { "url": "https://beacons.ai/1minuteanimals" },
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/link-in-bio-contact-leads-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 '{
  "startUrls": [
    {
      "url": "https://linktr.ee/thefashionsessions"
    },
    {
      "url": "https://beacons.ai/1minuteanimals"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/link-in-bio-contact-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/link-in-bio-contact-leads-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/avcaZjylMz2uKEJeW/builds/jxT2zItiEB12dpvTo/openapi.json