# Linktree Profile Details Scraper (`ecomscrape/linktree-profile-details-scraper`) Actor

Linktree Profile Details Scraper extracts user info from Linktree pages, including social links and bios. Perfect for lead generation, research, and competitor analysis, it saves time by automating data collection. Get accurate, structured data effortlessly! 🚀

- **URL**: https://apify.com/ecomscrape/linktree-profile-details-scraper.md
- **Developed by:** [ecomscrape](https://apify.com/ecomscrape) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 107 total users, 1 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 1.70 out of 5 stars

## Pricing

$20.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Contact

If you encounter any issues or need to exchange information, please feel free to contact us through the following link:
[My profile](https://apify.com/ecomscrape)


### Introduction

Linktree has revolutionized how creators, businesses, and influencers manage their online presence by providing a centralized hub for all their digital content and social media profiles. This platform creates a landing page where users can customize and include their links to social media profiles, blogs, YouTube channels, websites, podcasts, and more. As businesses and marketers recognize the value of this consolidated data, the need for efficient Linktree profile extraction has become increasingly important.

Manual collection of Linktree profile information is time-consuming and inefficient, especially when dealing with multiple profiles for lead generation, market research, or competitor analysis. Our Linktree Profile Details Scraper addresses this challenge by automating the data extraction process, allowing you to gather comprehensive profile information at scale while maintaining accuracy and consistency.

### Comprehensive Linktree Data Extraction Tool

The Linktree Profile Details Scraper is a specialized tool designed to extract valuable information from Linktree profiles efficiently. This powerful scraper navigates through Linktree pages and collects all available profile data, transforming it into a structured, actionable format that businesses and researchers can immediately utilize.

Our scraper stands out for its reliability and comprehensive data coverage. Unlike manual collection methods, it ensures consistent data formatting, reduces human error, and significantly accelerates the research process. The tool is particularly valuable for digital marketers, business development professionals, researchers, and anyone who needs to analyze multiple Linktree profiles for strategic purposes.

The scraper is designed to handle various Linktree profile configurations, from simple link collections to complex branded pages with multimedia content. It adapts to different profile layouts and extracts all available information, making it suitable for both individual profiles and bulk data collection projects.

### Input and Output Specifications

Example url: https://linktr.ee/lili.com.jp
    
Example Screenshot of profile information page:
    
![](https://i.postimg.cc/13X35Krv/Screenshot-from-2025-02-08-00-15-46.png)


#### Input Format

The scraper accepts a JSON configuration that allows for precise control over the extraction process. The input format includes several key parameters:


```json
{
  "max_retries_per_url": 2, // Maximum waiting time when accessing the links you provided.
  "proxy": { // Add a proxy to ensure that during the data collection process, you are not detected as a bot.
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL" 
    ],
    "apifyProxyCountry": "SG" // You should choose an Country that coincides with the Country you want to collect data from
  },
  "urls_or_usernames": [ // Links to profile information pages.
    "https://linktr.ee/lili.com.jp"
  ]
}
````

**Parameter Explanations:**

- **max\_retries\_per\_url**: Defines the maximum number of retry attempts for each URL when the initial request fails. This ensures robustness against temporary network issues or rate limiting.
- **proxy configuration**: Essential for avoiding bot detection and ensuring reliable data collection. The residential proxy option provides authentic IP addresses that appear as regular users.
- **apifyProxyCountry**: Should match the target audience's geography for optimal results and to avoid geo-blocking issues.
- **urls\_or\_usernames**: Accepts both full Linktree URLs and simple usernames. The scraper automatically formats usernames into complete URLs.

#### Output Format and Data Structure

You get the output from the Linktree Profile Details Scraper stored in a tab. The following is an example of the Information Fields collected after running the Actor.

```json
[ // List of profile information
  {
    "username": "lili.com.jp",
    "profile_picture": "https://ugc.production.linktr.ee/c06a6c4f-1351-4dae-8511-b4c3676fe0ed_IMG-9824.jpeg?io=true&size=avatar-v3_0",
    "title": "LiLi",
    "description": null,
    "social_urls": [],
    "links": [
      {
        "text": "Instagram",
        "thumbnail": null,
        "url": "https://instagram.com/lili.com.jp?igshid=YmMyMTA2M2Y="
      },
      {
        "text": "TikTok",
        "thumbnail": null,
        "url": "https://www.tiktok.com/@lili.com.jp?_t=8gr1p4ajPGb&_r=1"
      },
      {
        "text": "YouTube",
        "thumbnail": null,
        "url": "https://youtube.com/@LiLiTube_xx?si=i6M61tRfNoM2_UzG"
      },
      {
        "text": "illust Instagram",
        "thumbnail": null,
        "url": "https://instagram.com/lili.2nd.com.jp?igshid=YmMyMTA2M2Y="
      },
      {
        "text": "BE HAPPY AND SMILE",
        "thumbnail": null,
        "url": "https://behappyand.official.ec/"
      }
    ],
    "from_url": "https://linktr.ee/lili.com.jp"
  }, // ... Many other profile details
]
```

**Field Significance and Applications:**

- **Username**: Unique identifier for tracking and database organization, essential for cross-platform analysis and follow-up campaigns.
- **Profile Picture**: Visual branding element crucial for brand recognition studies, competitor analysis, and creating comprehensive contact databases.
- **Title**: Primary brand messaging that reveals positioning strategy, target market focus, and competitive differentiation approaches.
- **Description**: Rich source of keywords, value propositions, and messaging strategies that inform competitive intelligence and market research.
- **Social URLs**: Complete social media mapping enabling multi-platform outreach strategies, influence measurement, and comprehensive digital footprint analysis.
- **Links**: Business-critical information including current campaigns, product offerings, and conversion pathways that reveal business priorities and opportunities.
- **From URL**: Source tracking for data quality assurance and attribution purposes.

### Step-by-Step Usage Guide

#### Getting Started

1. **Prepare Your Input**: Compile a list of Linktree URLs or usernames you want to scrape. Organize them based on your research objectives, whether for competitor analysis, lead generation, or market research.

2. **Configure Proxy Settings**: Set up appropriate proxy configurations based on your target geography. Use residential proxies for better success rates and to avoid detection mechanisms.

3. **Set Retry Parameters**: Configure retry attempts based on your data quality requirements. Higher retry counts improve success rates but may increase processing time.

#### Best Practices for Optimal Results

- **Batch Processing**: Group similar profiles together to optimize processing efficiency and maintain consistent data quality across related targets.

- **Geographic Considerations**: Align proxy country settings with your target profiles' primary markets to avoid geo-restrictions and improve data accuracy.

- **Rate Limiting Awareness**: Allow appropriate intervals between large batches to respect platform guidelines and maintain long-term access reliability.

#### Common Issues and Solutions

**Connection Timeouts**: Increase max\_retries\_per\_url value and ensure stable proxy connections. Consider splitting large batches into smaller groups for better reliability.

**Empty Results**: Verify URL formatting and check if profiles are publicly accessible. Some private or restricted profiles may not be scrapeable.

**Incomplete Data**: Some Linktree profiles may have limited information. The scraper extracts all available data, so sparse profiles will naturally return fewer fields.

### Business Benefits and Applications

#### Time Efficiency and Scalability

The scraper saves significant time by automating data collection that would otherwise require manual effort. What might take hours of manual work can be completed in minutes, allowing teams to focus on analysis and strategy rather than data gathering.

#### Strategic Applications

**Lead Generation**: Build comprehensive contact databases with social media connections, enabling multi-channel outreach strategies that increase conversion rates and relationship building opportunities.

**Competitor Intelligence**: Monitor competitor activities, campaign messaging, and strategic partnerships through their Linktree profiles, providing valuable insights for competitive positioning and market opportunity identification.

**Market Research**: Analyze industry trends, popular platforms, and messaging patterns across multiple profiles to identify market gaps and emerging opportunities.

**Influencer Outreach**: Efficiently evaluate potential partnership opportunities by accessing complete social media profiles and understanding content creator focus areas and audience reach.

#### ROI and Business Value

The automated approach eliminates manual research costs while providing more comprehensive and accurate data than traditional methods. This efficiency gain allows teams to analyze larger sample sizes, leading to more statistically significant insights and better strategic decisions.

### Conclusion

The Linktree Profile Details Scraper represents a powerful solution for businesses and researchers who need efficient, accurate profile data extraction. By automating what was previously a manual, time-intensive process, it enables organizations to focus on strategic analysis and decision-making rather than data collection.

Whether you're building lead databases, conducting competitive research, or analyzing market trends, this scraper provides the comprehensive data foundation necessary for informed business decisions. Get started today and transform your Linktree data collection process from manual effort into automated intelligence.

## Your feedback

We are always working to improve Actors' performance. So, if you have any technical feedback about Linktree Profile Details Scraper or simply found a bug, please create an issue on the Actor's Issues tab in Apify Console.

# Actor input Schema

## `urls_or_usernames` (type: `array`):

Add the Specific profile urls or Usernames you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `max_retries_per_url` (type: `integer`):

Limit the number of retries for each URL if the scrape is detected as a bot or the page fails to load

## `proxy` (type: `object`):

Select proxies to be used by your scraper.

## Actor input object example

```json
{
  "urls_or_usernames": [
    "https://linktr.ee/lili.com.jp",
    "super"
  ],
  "max_retries_per_url": 2,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls_or_usernames": [
        "https://linktr.ee/lili.com.jp",
        "super"
    ],
    "max_retries_per_url": 2,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ecomscrape/linktree-profile-details-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 = {
    "urls_or_usernames": [
        "https://linktr.ee/lili.com.jp",
        "super",
    ],
    "max_retries_per_url": 2,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ecomscrape/linktree-profile-details-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls_or_usernames": [
    "https://linktr.ee/lili.com.jp",
    "super"
  ],
  "max_retries_per_url": 2,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ecomscrape/linktree-profile-details-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ecomscrape/linktree-profile-details-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linktree Profile Details Scraper",
        "description": "Linktree Profile Details Scraper extracts user info from Linktree pages, including social links and bios. Perfect for lead generation, research, and competitor analysis, it saves time by automating data collection. Get accurate, structured data effortlessly! 🚀",
        "version": "0.0",
        "x-build-id": "MQi5rNuYBAp6OIw4Y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ecomscrape~linktree-profile-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ecomscrape-linktree-profile-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ecomscrape~linktree-profile-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ecomscrape-linktree-profile-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ecomscrape~linktree-profile-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ecomscrape-linktree-profile-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls_or_usernames": {
                        "title": "URLs or Usernames of the profile to scrape",
                        "type": "array",
                        "description": "Add the Specific profile urls or Usernames you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_retries_per_url": {
                        "title": "Limit the number of retries for each URL",
                        "type": "integer",
                        "description": "Limit the number of retries for each URL if the scrape is detected as a bot or the page fails to load"
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your scraper."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
