# How to Scrape Linktree in 2026 (Python, Node, curl) (https://www.socialcrawl.dev/blog/how-to-scrape-linktree-2026)

> Linktree has no public API. Here is how to turn any linktr.ee URL into structured creator data with one GET request: real endpoint, real response, cursor-free, no headless browser.

Linktree does not publish a public API. There is no developer portal, no OAuth, no documented endpoint you can register for. So when you need to read a linktr.ee page programmatically, the choice is between driving a headless browser yourself or using a third-party endpoint that already parses the page. The fast route is one GET request:

```bash
curl "https://www.socialcrawl.dev/v1/linktree/page?url=https://linktr.ee/shawnmendes" \
  -H "x-api-key: $SOCIALCRAWL_KEY"
```

That resolves the linktr.ee URL to structured creator data (id, username, display name, avatar, and bio) in the same unified schema as every other platform. The rest of this guide covers what the response looks like, why no official API exists, the honest DIY picture, cross-platform enrichment, the legal framing, and the credits math.

<KeyTakeaway>
  There is no official Linktree API, so the working 2026 approach is a
  link-in-bio scraper endpoint: `GET /v1/linktree/page` takes a linktr.ee URL and
  one `x-api-key` header and returns the page owner's structured identity (id,
  username, display name, avatar, bio) in a unified schema, for 1 credit per
  call, with no headless browser to maintain. The free tier's 100 credits never
  expire.
</KeyTakeaway>

**Stack:** Python 3.10+ · `requests` · a [SocialCrawl API key](/docs/quickstart) (free tier: 100 credits)

---

## Is there a Linktree API?

No. Linktree is the canonical link-in-bio service, but it exposes no public developer API: there is nothing to register for, no OAuth flow, and no documented read endpoint. That is why "linktree api" is one of the clearest cases where the honest answer is "there isn't an official one, here is what to use instead."

Without an official API, two routes remain to read a linktr.ee page programmatically.

The first is do-it-yourself. A Linktree page is a JavaScript app that hydrates from a JSON blob embedded in the HTML, so you can fetch the page, locate that blob, and parse out the creator's identity and their link list. This works until Linktree renames a field, changes its hydration format, or adds a bot check, at which point every downstream job breaks until you patch the parser. It is a maintenance subscription paid in your own evenings, and it does not scale past a modest volume without proxies.

The second is a maintained link-in-bio API that does that parsing for you and returns a stable, versioned shape. This guide takes that route. The same pattern covers Linktree's competitors, so the [Komi](/platforms/komi) and [Linkbio](/platforms/linkbio) endpoints work identically for those services.

## Is it legal to scrape Linktree?

Scraping publicly accessible pages has repeatedly survived legal challenge in US courts (the _hiQ v. LinkedIn_ line of cases), and a public linktr.ee page is about as public as a web page gets: it exists specifically to be shared and visited. That is not the whole story: Linktree's Terms of Service govern automated access, and a creator's page can contain personal data subject to GDPR and CCPA, so bulk collection of individuals' data carries obligations regardless of how public the page is. Read our [legal and technical guide to social media scraping](/blog/social-media-scraping-legal-technical-guide) before shipping anything commercial, and talk to a lawyer if revenue depends on the answer. This section is a technical overview, not legal advice.

## Setup: one key, no browser

Install the only required dependency:

```bash
pip install requests
```

Get an API key at [socialcrawl.dev](https://www.socialcrawl.dev), then **Dashboard → API Keys**. New accounts get 100 free credits, the Linktree endpoint costs 1 credit per call, and credits never expire. Keep the key out of your source:

```bash
```

There is no headless browser to install, no proxy pool to rotate, and no JSON blob to reverse-engineer. One header does it.

## Scraping a Linktree page

The endpoint is [`GET /v1/linktree/page`](/platforms/linktree/page). It takes one required parameter, `url`, the full linktr.ee page URL. There is no pagination: a Linktree page is a single resource, so one call returns it.

```python

API_KEY = os.environ["SOCIALCRAWL_API_KEY"]
BASE = "https://www.socialcrawl.dev/v1"

resp = requests.get(
    f"{BASE}/linktree/page",
    params={"url": "https://linktr.ee/shawnmendes"},
    headers={"x-api-key": API_KEY},
    timeout=30,
)
page = resp.json()["data"]["author"]
print(page["username"], page["display_name"])
```

Here is a real response from that exact call:

```json
{
  "success": true,
  "platform": "linktree",
  "endpoint": "/v1/linktree/page",
  "data": {
    "author": {
      "id": "20577221",
      "username": "shawnmendes",
      "display_name": "shawnmendes",
      "avatar_url": "https://ugc.production.linktr.ee/e11a699a-4079-4751-a154-8cc7026ed6bd_453831070-1851044942043165-6930315343607466007-n.jpeg",
      "bio": null,
      "verified": null,
      "followers": null,
      "following": null
    },
    "computed": { "language": null, "content_category": null }
  },
  "credits_used": 1,
  "credits_remaining": 99
}
```

The identity comes back in the canonical `author` object: `id`, `username`, `display_name`, `avatar_url`, and `bio` use the same field names as the [Instagram, TikTok, and YouTube](/platforms) profile endpoints, so the same parser reads a Linktree page and an Instagram profile. The fields Linktree genuinely does not expose (follower counts, verification) come back `null` rather than missing, so your schema is stable. Aggregate counters are null because Linktree simply has none. To inspect the full live response for any page, paste a linktr.ee URL into the [Explorer](/explorer).

## The same call in Node and curl

The endpoint, parameter, and envelope are identical across languages. Node:

```ts
const res = await fetch(
  "https://www.socialcrawl.dev/v1/linktree/page?url=" +
    encodeURIComponent("https://linktr.ee/shawnmendes"),
  { headers: { "x-api-key": process.env.SOCIALCRAWL_API_KEY! } },
);
const { data } = await res.json();
console.log(data.author.username, "→", data.author.avatar_url);
```

curl, with a different page:

```bash
curl "https://www.socialcrawl.dev/v1/linktree/page?url=https://linktr.ee/charlidamelio" \
  -H "x-api-key: $SOCIALCRAWL_KEY"
```

<CTA variant="inline" />

## Resolving a list of Linktree pages

The real workload is rarely one page. It is usually a list of creator link-in-bio URLs you want to resolve into structured identities: enriching a creator database, deduplicating handles across platforms, or checking which creators still run an active page. Because there is no pagination, resolving a list is a flat loop with error handling.

```python
def resolve_linktree(urls: list[str]) -> list[dict]:
    """Resolve linktr.ee URLs to creator identities, one credit each."""
    out = []
    for url in urls:
        resp = requests.get(
            f"{BASE}/linktree/page",
            params={"url": url},
            headers={"x-api-key": API_KEY},
            timeout=30,
        )
        payload = resp.json()
        if payload.get("success"):
            out.append({"url": url, **payload["data"]["author"]})
        else:
            out.append({"url": url, "error": payload["error"]["type"]})
    return out

rows = resolve_linktree([
    "https://linktr.ee/shawnmendes",
    "https://linktr.ee/charlidamelio",
])
```

To run this concurrently, a `ThreadPoolExecutor(max_workers=40)` stays under the 50-concurrent-request limit and clears a few thousand pages in minutes.

## Cross-platform enrichment: the real use case

A link-in-bio URL is a hub, and its value is what it connects to. Because the Linktree endpoint returns a creator identity in the same schema as every social platform, the natural next step is enrichment: take the `username`, look the creator up on the platforms that matter to you, and merge the profiles. The [Instagram](/platforms/instagram), [TikTok](/platforms/tiktok), and [YouTube](/platforms/youtube) profile endpoints return the same `author` shape, so joining a Linktree identity to a full social profile is a field match, not a rewrite. That is the payoff of a unified schema: one parser, many platforms, no per-service special-casing.

## Handling errors

Failures use the same envelope with `success: false` and a typed error object.

| Error type             | Status | What it means                          | Your move                                   |
| ---------------------- | ------ | -------------------------------------- | ------------------------------------------- |
| `RESOURCE_NOT_FOUND`   | 404    | Page removed or URL typo'd             | Skip it. Empty upstream refunds the credit. |
| `UPSTREAM_ERROR`       | 502    | Linktree hiccuped                      | Retry with backoff; credit refunded.        |
| `SERVICE_UNAVAILABLE`  | 503    | Circuit breaker open                    | Honor the `Retry-After` header.             |
| `CONCURRENCY_LIMIT`    | 429    | More than 50 concurrent requests / key | Cap your worker pool below 50.              |
| `INSUFFICIENT_CREDITS` | 402    | Balance below the call cost            | Top up.                                     |

There is no queries-per-minute quota, empty-upstream 404s and 502s refund the credit, and repeat requests for the same page inside the cache window cost 0 credits. The full matrix is in the [error handling docs](/docs/errors).

## Scraping Linktree at scale: the credits math

The endpoint is 1 credit per page, flat.

| Workload                        | Requests | Credits |
| ------------------------------- | -------- | ------- |
| One page                        | 1        | 1       |
| 100 creator pages               | 100      | 100     |
| 2,500 creator pages             | 2,500    | 2,500   |
| 20,000 creator pages            | 20,000   | 20,000  |

The free tier's 100 credits cover the first rows. Past that, [pricing](/pricing) is pay-as-you-go and credits never expire: 2,500 credits is £15 and the Growth plan's 20,000 (£49) resolves twenty thousand pages once, or five thousand pages four times as your database refreshes. Cached repeats are free, so re-running a resolve job against pages you fetched recently does not double-charge.

## Frequently asked questions

### Does Linktree have an API?

No. Linktree publishes no public developer API, OAuth flow, or documented read endpoint. To read a linktr.ee page programmatically you either parse the page's embedded JSON yourself or use a third-party link-in-bio API. `GET /v1/linktree/page` returns a page's creator identity for 1 credit with just an `x-api-key`.

### How do I scrape a Linktree page?

Send `GET /v1/linktree/page` with the full linktr.ee URL in the `url` parameter and an `x-api-key` header. The response returns the page owner's identity (id, username, display name, avatar, bio) in a unified `author` object. There is no pagination, because a Linktree page is a single resource.

### Is scraping Linktree legal?

A public linktr.ee page is created to be shared, and reading public pages has meaningful precedent in its favor, but Linktree's Terms govern automated access and a creator page can contain personal data under GDPR and CCPA. Bulk collection of individuals' data carries obligations regardless of how public the page is. Check Linktree's current terms and consult counsel for commercial use. This is a technical overview, not legal advice.

### Can I scrape other link-in-bio services?

Yes. The same pattern and schema cover Linktree's competitors: the [Komi](/platforms/komi) and [Linkbio](/platforms/linkbio) endpoints resolve those services' pages into the same `author` shape, so one parser handles every link-in-bio platform.

### How much does it cost to scrape Linktree?

Each page costs 1 credit. New accounts get 100 credits that never expire, then pricing is pay-as-you-go from £15 for 2,500 credits. Cached repeats are free, so refreshing a database you already resolved does not double-charge.

### What can I do with Linktree data?

The common jobs are creator-database enrichment (resolving a link-in-bio URL to a structured identity), cross-platform deduplication (matching a Linktree username to Instagram, TikTok, and YouTube profiles), and monitoring which creators keep an active page. Because the identity comes back in the same schema as every platform, joining it to full social profiles is a field match.

### Do I need a headless browser to scrape Linktree?

No. Because there is no official API, the DIY route means driving a headless browser or reverse-engineering the page's embedded JSON, both of which break when Linktree changes its front end. A maintained link-in-bio API absorbs those changes and returns a stable shape, so you never touch a browser.

---

## Where to go from here

You now have a Linktree resolver that costs 1 credit per page and survives Linktree's front-end changes because maintaining that compatibility is the API's job, not yours. Next steps: browse the [Linktree platform page](/platforms/linktree), apply the same pattern to [Komi](/platforms/komi) and [Linkbio](/platforms/linkbio), or enrich the identities against the [Instagram](/platforms/instagram) and [TikTok](/platforms/tiktok) profile endpoints. Start with the free tier: [100 credits, no card](/pricing) resolves a hundred pages, more than enough to find out whether the data answers your question.

<CTA variant="hard" />

<RelatedPosts
  currentSlug="how-to-scrape-linktree-2026"
  tags={["development", "learning"]}
  locale="en"
/>

<ArticleJsonLd />

<BreadcrumbJsonLd />

<FaqJsonLd
  questions={[
    {
      question: "Does Linktree have an API?",
      answer:
        "No. Linktree publishes no public developer API, OAuth flow, or documented read endpoint. To read a linktr.ee page programmatically you either parse the page's embedded JSON yourself or use a third-party link-in-bio API. GET /v1/linktree/page returns a page's creator identity for 1 credit with just an x-api-key.",
    },
    {
      question: "How do I scrape a Linktree page?",
      answer:
        "Send GET /v1/linktree/page with the full linktr.ee URL in the url parameter and an x-api-key header. The response returns the page owner's identity (id, username, display name, avatar, bio) in a unified author object. There is no pagination, because a Linktree page is a single resource.",
    },
    {
      question: "Is scraping Linktree legal?",
      answer:
        "A public linktr.ee page is created to be shared, and reading public pages has meaningful precedent in its favor, but Linktree's Terms govern automated access and a creator page can contain personal data under GDPR and CCPA. Bulk collection of individuals' data carries obligations regardless of how public the page is. Check Linktree's current terms and consult counsel for commercial use. This is a technical overview, not legal advice.",
    },
    {
      question: "Can I scrape other link-in-bio services?",
      answer:
        "Yes. The same pattern and schema cover Linktree's competitors: the Komi and Linkbio endpoints resolve those services' pages into the same author shape, so one parser handles every link-in-bio platform.",
    },
    {
      question: "How much does it cost to scrape Linktree?",
      answer:
        "Each page costs 1 credit. New accounts get 100 credits that never expire, then pricing is pay-as-you-go from £15 for 2,500 credits. Cached repeats are free, so refreshing a database you already resolved does not double-charge.",
    },
    {
      question: "What can I do with Linktree data?",
      answer:
        "The common jobs are creator-database enrichment (resolving a link-in-bio URL to a structured identity), cross-platform deduplication (matching a Linktree username to Instagram, TikTok, and YouTube profiles), and monitoring which creators keep an active page. Because the identity comes back in the same schema as every platform, joining it to full social profiles is a field match.",
    },
    {
      question: "Do I need a headless browser to scrape Linktree?",
      answer:
        "No. Because there is no official API, the DIY route means driving a headless browser or reverse-engineering the page's embedded JSON, both of which break when Linktree changes its front end. A maintained link-in-bio API absorbs those changes and returns a stable shape, so you never touch a browser.",
    },
  ]}
/>