# Link.me Scraper \[Only $5💰] | Bio, Emails & Social Links (`ahmed_jasarevic/linkme-bio-email-scraper`) Actor

Extract emails, social handles, links and bio from Link.me profiles for lead generation and creator outreach. Fully server-rendered, no login, export JSON at $5 per 1,000 profiles.

- **URL**: https://apify.com/ahmed_jasarevic/linkme-bio-email-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.80 / 1,000 results

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

## Link.me Bio & Email Scraper

Turn Link.me profiles into structured leads: bio text, verified flag, email addresses, social handles and regular links, at **$5.00 per 1,000 profiles**. It is fully server-rendered, so there is no browser, no proxy and no login, and each row is a clean JSON record ready for outreach or analysis.

### Main Use Cases

- **Email lead generation** - collect public emails published on Link.me bio pages.
- **Influencer contact lists** - build reachable creator lists with their social handles in one run.
- **Creator email finder** - resolve a single Link.me profile to its emails and links.
- **Outbound prospecting data** - export bio, emails and socials for CRM enrichment.
- **Social links extraction** - grab a profile's Instagram, TikTok, YouTube, X and other handles.
- **Agency and BD research** - qualify Link.me profiles by verified status, bio and link set.

### How It Works - Extract Link.me Emails And Social Links Without A Browser

Link.me pages are fully server-rendered, so the Actor fetches each profile over plain HTTP and parses the returned HTML. It:

1. Reads `bio`, the `username` and the verified badge (`img.verifyicon` or `img[alt="Verified"]`).
2. Collects emails from `mailto:` links and from any address found in the visible text or embedded JSON-LD.
3. Splits outbound links into `socialLinks` (known social and platform domains) and `regularLinks` (everything else).
4. Processes pages concurrently with a bounded pool (`maxConcurrency`).

Only `link.me` hosts are processed; URLs from other domains are skipped and counted in the run log. No JavaScript execution, no proxy and no TLS impersonation is needed. Non-paying users get a 10-row preview per run; paying users run unlimited.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `startUrls` | array (object) | Yes | `https://link.me/sugasean` prefill | Link.me profile URLs, e.g. `https://link.me/username`. Each entry is an Apify request-list source (`{ "url": "..." }`). |
| `maxConcurrency` | integer | No | `10` | Maximum number of pages fetched simultaneously. Clamped to 1-50. Higher is faster but heavier. |

### Output Fields

One row per valid Link.me profile. Fields:

- `username` - the Link.me handle.
- `sourceUrl` - the profile URL that produced the row.
- `emails` - array of email addresses found on the page (sorted, de-duplicated).
- `socialLinks` - array of social / platform links (sorted).
- `regularLinks` - array of all other outbound links (sorted).
- `bio` - the profile bio text.
- `isVerified` - whether the profile shows Link.me's verified badge.
- `scrapedAt` - ISO timestamp of when the row was scraped.

The `overview` dataset view shows `username`, `emails`, `sourceUrl`, `isVerified`, `bio` and `scrapedAt`. On the run page, open the Storage tab to view or export the dataset.

### Example Input And Output

Example input:

```json
{
  "startUrls": [
    { "url": "https://link.me/sugasean" },
    { "url": "https://link.me/examplecreator" }
  ],
  "maxConcurrency": 10
}
```

Example output row:

```json
{
  "username": "sugasean",
  "sourceUrl": "https://link.me/sugasean",
  "emails": ["hello@example.com"],
  "socialLinks": [
    "https://instagram.com/examplecreator",
    "https://tiktok.com/@examplecreator",
    "https://youtube.com/@examplecreator"
  ],
  "regularLinks": [
    "https://example.com/shop",
    "https://example.com/newsletter"
  ],
  "bio": "Founder, creator and educator. Links below.",
  "isVerified": true,
  "scrapedAt": "2026-10-11T09:30:00.000Z"
}
```

### Integrations & Automation

- **Apify API** - run via `POST https://api.apify.com/v2/acts/{actorId}/runs`, export via `GET /v2/datasets/{datasetId}/items?clean=true&format=json`.
- **Schedules** - run weekly to re-check a saved list of profiles for new emails or social handles (recurring usage also improves Store recommendation signals).
- **Webhooks** - fire on run finished to push new leads into a CRM or lead database.
- **Zapier / Make** - via the Apify integration, e.g. new profiles into Google Sheets, Airtable or HubSpot.
- **Pay-per-event** - $5.00 per 1,000 profiles (`result`), plus a $0.00005 run start.

### Related Actors

- [linktree-beacons-bio-email-scraper-extract-leads](https://apify.com/ahmed_jasarevic/linktree-beacons-bio-email-scraper-extract-leads): the same lead-extraction approach for Linktree and Beacons pages.
- [instagram-email-phone-scraper](https://apify.com/memo23/instagram-email-phone-scraper): follows the link in bio and reads contact pages behind it for Instagram contacts.
- [linktree-scraper](https://apify.com/rl1987/linktree-scraper): parses Linktree pages into links, bio, socials and emails.
- [linktree-bio-link-extractor](https://apify.com/thirdwatch/linktree-bio-link-extractor): extracts every link from link-in-bio pages across several platforms.
- [ko-fi-profile-scraper](https://apify.com/ahmed_jasarevic/ko-fi-profile-scraper): creator profile data (supporters, tiers, social links) to enrich creator lists.

### FAQ

#### What is Link.me and does it have an API?

Link.me is a link-in-bio service. It has no public content API for third parties, but every profile page is server-rendered, so its data can be read directly from the HTML. This Actor does exactly that, with no key.

#### How do I extract emails from Link.me profiles?

Pass the profile URLs in `startUrls`. The Actor reads `mailto:` links and any addresses found in the visible text or embedded JSON-LD, and returns them in the `emails` array.

#### What are the alternatives to this Link.me scraper?

Store alternatives include ahmed_jasarevic/linktree-beacons-bio-email-scraper-extract-leads ($0.0048 per result, Linktree and Beacons), memo23/instagram-email-phone-scraper (Instagram link-in-bio contacts), rl1987/linktree-scraper ($0.005 per page) and thirdwatch/linktree-bio-link-extractor ($0.003 per result). This actor targets link.me specifically at $5.00 per 1,000 profiles.

#### Can I get an influencer's social handles in one run?

Yes. Every row includes `socialLinks` with the profile's social and platform links, split from `regularLinks`. Combine it with `bio` and `isVerified` to qualify a creator quickly.

#### Does it also work on Linktree and Beacons?

No. This actor only processes `link.me` hosts; other domains are skipped and reported in the run log. Use the companion linktree-beacons-bio-email-scraper-extract-leads actor for Linktree and Beacons pages.

#### Is there a free preview?

Yes. Non-paying Apify users get a 10-row preview per run; paying users run unlimited up to the number of valid profiles in `startUrls`.

#### How much does it cost?

$5.00 per 1,000 profiles (`result`), plus a $0.00005 run start. There is no proxy or browser cost, so a run stays cheap per profile.

### SEO Keywords

link.me scraper, link.me api, linkme data, scrape link.me, link in bio data, email lead generation, influencer contact list, bio link scraper, creator email finder, outbound prospecting data, influencer outreach, link.me profile emails, social links extraction, link in bio emails, creator bio data, link.me alternative, verified profile badge, linktree emails, link in bio contact scraper, email finder from bio link

### For AI Agents & LLM Apps

- **Purpose**: returns one JSON row per Link.me profile with bio, public emails, social links, regular links and a verified flag.
- **Minimal working input**:

```json
{ "startUrls": [{ "url": "https://link.me/sugasean" }] }
```

- **Output field names**: `username, sourceUrl, emails, socialLinks, regularLinks, bio, isVerified, scrapedAt`.
- **Behaviors an agent should know**:
  - `startUrls` is required and uses the Apify request-list format (`{ "url": "..." }` entries).
  - Only `link.me` hosts are processed; any other domain is skipped and logged, and produces no row.
  - `emails`, `socialLinks` and `regularLinks` are arrays; a profile with no public email returns an empty array, not an error.
  - `maxConcurrency` defaults to 10 and is clamped to 1-50; it controls parallel page fetches, not the number of rows.
  - Non-paying users are capped at a 10-row preview; paying users are unlimited.
  - No proxy is needed and none is configured by the input schema.
- **Billing**: pay-per-event - $0.005 per profile row (`result`), $0.00005 per run start. Tiered pricing may be lower on higher Apify plans.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Link.me. It accesses only publicly available Link.me profile pages, does not log in and does not bypass authentication.

The output includes personal contact data such as email addresses and social handles. Do not use this data for unsolicited commercial outreach in violation of applicable law (for example CAN-SPAM, GDPR or CCPA). Users are responsible for complying with Link.me's terms of service and applicable data-protection law, and should keep records of the lawful basis for any outreach.

# Actor input Schema

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

List of Link.me profile URLs (e.g. https://link.me/username).

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

Maximum number of pages fetched simultaneously.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://link.me/sugasean"
    }
  ],
  "maxConcurrency": 10
}
```

# Actor output Schema

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

Link to the default dataset containing the scraped Link.me leads.

# 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://link.me/sugasean"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/linkme-bio-email-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://link.me/sugasean" }] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/linkme-bio-email-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://link.me/sugasean"
    }
  ]
}' |
apify call ahmed_jasarevic/linkme-bio-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/linkme-bio-email-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/dXJGnsv82wNZl29d4/builds/C0TW2GIEI4KF2uHOS/openapi.json