How to Scrape Linktree in 2026 (Python, Node, curl)

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:

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.

Stack: Python 3.10+ · requests · a SocialCrawl API key (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 and 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 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:

pip install requests

Get an API key at 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:

export SOCIALCRAWL_API_KEY=sc_your_api_key_here

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

import os
import requests

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:

{
  "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 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.

The same call in Node and curl

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

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:

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

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.

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, TikTok, and 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.

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 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 and 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, apply the same pattern to Komi and Linkbio, or enrich the identities against the Instagram and TikTok profile endpoints. Start with the free tier: 100 credits, no card resolves a hundred pages, more than enough to find out whether the data answers your question.