# ContactInBio Scraper — creator socials, email, music & stores (`ahmed_jasarevic/contactinbio-scraper`) Actor

Pull structured ContactInBio creator link-in-bio profiles as JSON: socials, public email, music, payment, video, smart-link and product counts, plus store presence — fast, no browser needed, ideal for enrichment and AI apps.

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

## Pricing

from $3.00 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## ContactInBio Scraper — Extract creator link-in-bio profiles, socials, music, payments & stores

Pull structured profile data from contactinbio.com creator pages — socials, contact email, music, payment, video, smart-link and product counts, and store presence — as clean JSON, with no browser required.

### Main Use Cases

- **Build enriched creator databases** — combine socials, email and category counts from hundreds of ContactInBio profiles into one table.
- **OnlyFans / fan-page research** — see which creators link payment, music, video and smart-link content, plus `hasStore` presence, at a glance.
- **Lead gen & outreach-lite** — collect publicly listed contact details and social handles for legitimate, compliant follow-up.
- **Competitor & content benchmarking** — compare link/payment/music/video counts across creator profiles over time.
- **Bulk username extraction** — feed up to thousands of `usernames` and get every profile's structured data in one run.
- **Power AI/LLM apps & monitoring** — feed clean, typed JSON into agents, dashboards, or recurring watchlists.

### How It Works / ContactInBio creator link-in-bio extraction

ContactInBio is a link-in-bio SaaS used by creators (notably OnlyFans and fan-page creators) to present socials, music, payment links, videos, smart links, products, and stores on one page. This actor goes directly to each public profile page and extracts its structured content **without opening a browser**, so it is fast and cheap.

For each profile it captures the `username`, `displayName`, `domain`, `profileUrl`, `avatarUrl`, `bio`, **public `email`** (when shown), and counts for `linkCount`, `socialCount`, `musicCount`, `paymentCount`, `videoCount`, `smartLinkCount`, `productCount`, plus `hasStore` (a store link present). A `scrapedAt` timestamp marks when each profile was fetched.

You can target profiles either by **direct URLs** (`startUrls`, e.g. `{"url":"https://contactinbio.com/example"}`) or by **handles** (`usernames`, e.g. `"example"`). `maxItems` caps results and `maxConcurrency` controls parallel requests; `proxyConfiguration` adds residential/datacenter proxies when needed.

### Input

| Field | Type | Required | Default | Notes |
|-------|------|----------|---------|-------|
| `startUrls` | array of `{"url": "https://contactinbio.com/example"}` | No | `[]` | Direct profile URLs to scrape. |
| `usernames` | array of strings | No | `[]` | Creator handles, e.g. `"example"`. |
| `maxItems` | integer | No | `Infinity` | Cap on number of profiles processed. |
| `maxConcurrency` | integer | No | `1` | Number of parallel requests. |
| `proxyConfiguration` | object (proxy config) | No | — | Proxies for blocking/rate-limit avoidance. |

### Output

Each dataset item is one ContactInBio profile:

- `username` — handle; `displayName` — creator display name; `domain`/`profileUrl` — profile location.
- `avatarUrl` — profile avatar; `bio` — profile description text.
- `email` — **public email shown on the profile**, when available (treat as PII — see Legal & Compliance).
- Counters — `linkCount`, `socialCount`, `musicCount`, `paymentCount`, `videoCount`, `smartLinkCount`, `productCount`.
- `hasStore` — boolean: whether a store link is present.
- `scrapedAt` — ISO timestamp of when the profile was scraped.

### Example Input

```json
{
  "usernames": ["example", "creator_official"],
  "startUrls": [{ "url": "https://contactinbio.com/anothercreator" }],
  "maxItems": 100,
  "maxConcurrency": 5,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### Example Output

```json
{
  "username": "example",
  "displayName": "Example Creator",
  "domain": "contactinbio.com",
  "profileUrl": "https://contactinbio.com/example",
  "avatarUrl": "https://contactinbio.com/avatars/example.jpg",
  "bio": "Links to my music, videos and tip jar.",
  "email": "hello@example.com",
  "linkCount": 12,
  "socialCount": 4,
  "musicCount": 3,
  "paymentCount": 2,
  "videoCount": 1,
  "smartLinkCount": 1,
  "productCount": 0,
  "hasStore": false,
  "scrapedAt": "2026-08-29T10:15:30.000Z"
}
```

### Scheduling, Monitoring & Automation

ContactInBio pages change as creators add content, so run this actor on a **recurring schedule** to keep data fresh. Use Apify's scheduled runs (e.g. daily or weekly) to watch `linkCount`, `paymentCount`, `musicCount`, `hasStore`, `email` and other fields, alert on changes, and feed trend data into dashboards or lead pipelines. Bulk username batches and `startUrls` can be combined, then automated via the Apify API or webhooks for a fully hands-off pipeline.

### FAQ

**Why use this actor instead of an official ContactInBio API?** ContactInBio does not provide a public, documented data-extraction API for profile-level scraping. This actor fills that gap by reading each public profile page directly and returning structured JSON, so you get the data without building and maintaining your own scrapers or fighting anti-bot protections alone.

**What are the alternatives?** Alternatives include Linkpop, Komi, and Milkshake scrapers for other link-in-bio platforms, a generic web/crawler actor pointed at contactinbio.com, or manual copying (slow and error-prone). This actor is purpose-built and returns clean, typed fields with no post-processing.

**Can I scrape many creators at once?** Yes — pass arrays of `usernames` (and/or `startUrls`) and raise `maxConcurrency`. Give it thousands of handles and it will process them in a single run, bounded by `maxItems`.

**Does it need a browser?** No. It extracts structured data directly from the page, making runs fast and cost-efficient.

**Is the email always returned?** Only when the creator publicly lists a contact email on their profile. If absent, `email` is empty — don't treat missing data as "no email."

**Is this GEO/AI-agent friendly?** Yes — the dataset view is `overview`, fields are stable and typed, and outputs are ideal for LLM apps, RAG, and automated pipelines (see below).

### For AI Agents & LLM Apps

This actor is built as a **machine-readable data source**. Its purpose is to convert public ContactInBio creator pages into clean, typed JSON that agents, RAG pipelines, and analytics apps can consume directly.

**Minimal input:** just `usernames: ["handle"]` (or a `startUrls` entry) — everything else is optional.

**Output fields an app can rely on:** `username`, `displayName`, `domain`, `profileUrl`, `avatarUrl`, `bio`, `email`, `linkCount`, `socialCount`, `musicCount`, `paymentCount`, `videoCount`, `smartLinkCount`, `productCount`, `hasStore`, `scrapedAt`.

**Non-obvious behaviors to handle in code:**

- `email` may be empty/missing for many creators — treat it as optional and never assume presence.
- Count fields (`linkCount`, `paymentCount`, etc.) are integers; `hasStore` is a boolean.
- `maxItems` caps total profiles, not per-field; set it deliberately to bound cost.
- `scrapedAt` per item lets you dedupe and track freshness across scheduled runs.

**Billing:** runs are **metered, not fixed-price** — you pay based on actual compute/data volume used, so start small, set `maxItems`, and scale `maxConcurrency` only as needed. There is no invented flat price; monitor usage in the Apify dashboard.

### Legal & Compliance Disclaimer

This actor is an **independent, community-built tool** and is **not affiliated with, endorsed by, or sponsored by ContactInBio**. It accesses **only public pages** and does not bypass login, paywalls, or access-restricted content.

You are solely responsible for complying with ContactInBio's Terms of Service, applicable website rules, and all relevant laws — including data-protection rules such as **GDPR** and electronic-marketing rules such as **CAN-SPAM**.

**Note on email data:** the output may include a creator's **public contact `email`**. Do **not** use it for unsolicited outreach, bulk marketing, or spam — doing so can violate CAN-SPAM, GDPR, and related privacy/marketing regulations. Use collected public data responsibly and at your own risk.

### SEO Keywords

contactinbio scraper, contactinbio profile scraper, contactinbio data extraction, contactinbio email extractor, link in bio scraper, link-in-bio scraper, creator scraper, onlyfans creator scraper, onlyfans fan page scraper, creator data extraction, scrape creator socials, creator email scraper, scrape contactinbio profiles, contactinbio csv, contactinbio json, extract creator profiles, link in bio data api, creator analytics, scrape creator links, creator link page scraper, bulk username scraper, monitor creator profiles, contactinbio without browser, scrape fan pages, creator database

### Related Actors

Verified related actors on Apify that pair well with this one. All links point to real, publicly available actors.

- [Instagram Profile Scraper](https://apify.com/apify/instagram-profile-scraper)
- [Instagram Scraper](https://apify.com/apify/instagram-scraper)
- [TikTok Profile Scraper](https://apify.com/clockworks/tiktok-profile-scraper)

# Actor input Schema

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

Direct ContactInBio profile URLs to scrape, e.g. https://edwin.contactin.bio/ or https://jeremie21.ctcin.bio/. Use this when you already have full profile links.

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

List of ContactInBio usernames (without @). Each username is tried across all supported domains: <user>.contactin.bio, <user>.ctcin.bio, <user>.contactinbio.com and allmy.link/<user>. The first domain that resolves to a real profile is scraped (duplicates are de-duplicated by username).

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

Maximum number of profiles to extract. Free users are capped at 10 profiles regardless of this value; paid users get the full amount.

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

Number of profile pages fetched in parallel. Lower it if you hit rate limits.

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

Proxy settings. All requests are routed through the Apify proxy by default to avoid IP bans. Residential groups are recommended for higher success on protected pages.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://edwin.contactin.bio/"
    },
    {
      "url": "https://jeremie21.contactin.bio/"
    }
  ],
  "usernames": [
    "edwin",
    "jeremie21",
    "coli777"
  ],
  "maxItems": 100,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        {
            "url": "https://edwin.contactin.bio/"
        },
        {
            "url": "https://jeremie21.contactin.bio/"
        }
    ],
    "usernames": [
        "edwin",
        "jeremie21"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/contactinbio-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://edwin.contactin.bio/" },
        { "url": "https://jeremie21.contactin.bio/" },
    ],
    "usernames": [
        "edwin",
        "jeremie21",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/contactinbio-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://edwin.contactin.bio/"
    },
    {
      "url": "https://jeremie21.contactin.bio/"
    }
  ],
  "usernames": [
    "edwin",
    "jeremie21"
  ]
}' |
apify call ahmed_jasarevic/contactinbio-scraper --silent --output-dataset

```

## MCP server setup

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