# Website Social Links Extractor (`scrapers-hub/website-social-links-extractor`) Actor

Website Social Links Extractor finds Facebook, Twitter, Instagram and YouTube profile links on any website. 🔗 A fast way to enrich CRM records, map competitor social presence and build influencer or brand contact datasets.

- **URL**: https://apify.com/scrapers-hub/website-social-links-extractor.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### 🔗 Website Social Links Extractor – Find Facebook, Twitter, Instagram & YouTube Profiles from Any URL

The **Website Social Links Extractor** scans any list of websites and pulls out the social media profile URLs those sites link to — Facebook, Twitter, Instagram and YouTube — returning one clean JSON record per domain. Give it a list of company homepages, e-commerce stores, agency sites or prospect URLs, and it hands back the social handles that were buried in the header, the footer, the contact page or an icon strip nobody wants to click through manually.

This social links extractor exists because the same tedious job keeps reappearing. Sales teams need the social presence of 5,000 prospects. Agencies need to audit which brands actually run a YouTube channel. CRM records go stale because nobody updates the Instagram field. Doing that by hand costs a person hours per hundred sites; doing it with a social media links scraper costs one run. The actor uses plain HTTP requests and an HTML parser rather than a headless browser, so it moves quickly through large URL lists without the overhead of rendering full pages.

***

### 📊 What Data Can You Extract with This Social Links Scraper?

Every website you submit produces one flat record. The schema is deliberately small and completely predictable, which is exactly what you want when the output is going straight into a CRM import or a spreadsheet column.

| Category | Fields | What it gives you |
|---|---|---|
| 🌐 Source identity | `scrapedUrl` | The website URL that was scanned, so every row is traceable back to the exact input you submitted. |
| 👍 Facebook presence | `facebook` | The Facebook page or profile URL linked from the site, typically the brand's official business page. |
| 🐦 Twitter presence | `twitter` | The Twitter/X profile URL the site links to, usually the company's primary handle. |
| 📸 Instagram presence | `instagram` | The Instagram profile URL found on the page — the field most in demand for consumer brands and e-commerce. |
| ▶️ YouTube presence | `youtube` | The YouTube channel URL, whether it is a classic channel link or a modern `@handle` URL. |
| ⚠️ Run diagnostics | `error` | A human-readable message explaining why a particular URL could not be processed, populated only when something went wrong. |

The field most people underestimate is **`error`**. Because it appears per row rather than failing the whole run, a batch of 2,000 prospect sites gives you a precise, machine-readable list of exactly which domains were unreachable, blocked or malformed — turning a silent gap in your data into an actionable retry queue.

***

### 🌟 Key Features of the Website Social Links Extractor

| Feature | Description |
|---|---|
| 🎯 Four-platform coverage | Extracts Facebook, Twitter, Instagram and YouTube profile URLs in a single pass over each website. |
| 📋 Bulk URL input | Accepts a list of start URLs in one run, so you can process an entire prospect list, client roster or competitor set at once. |
| ⚡ HTTP-first architecture | Built on `httpx` and the `parsel` selector library instead of a browser, keeping runs fast and light on compute for standard HTML pages. |
| 🧱 Flat, stable schema | Every record carries the same six keys, so CSV exports never shift columns and database inserts never break on a missing field. |
| 🧯 Per-URL error isolation | A failing website populates its own `error` field instead of aborting the run — the remaining URLs are processed normally. |
| 🔍 Whole-page scanning | Social links are found wherever they live: header navigation, footer icon strips, contact sections or inline body content. |
| 🆓 Free to run | The actor carries no per-result charge; you only consume standard Apify platform compute. |
| 📦 Multi-format export | Results land in an Apify dataset and export to JSON, CSV, Excel, XML or HTML, or stream out through the API. |
| 🔌 Integration ready | Works with Apify schedules, webhooks and the standard API client, so extracted social profiles can flow directly into downstream systems. |

***

### 🚀 Why Choose This Social Links Extractor?

**Zero configuration per website.** There are no selectors to write, no per-domain templates to maintain and no rules to update when a brand redesigns its footer. The social links extractor takes a list of URLs and applies the same detection logic to every one of them, which means adding a new prospect to your pipeline costs exactly one line of input.

**Built for bulk, not one-offs.** A single URL is a job for your browser. The reason this actor exists is the list of two thousand domains sitting in a spreadsheet column. The `startUrls` array accepts as many entries as you want to submit, and the per-row `error` field means one dead domain never costs you the other 1,999 results.

**Genuinely lightweight.** Because extraction runs on direct HTTP requests with a fast parser rather than launching a browser per page, throughput stays high and compute stays low. For the standard server-rendered HTML that the overwhelming majority of company websites still serve, a headless browser is expensive overhead you do not need.

**Output that drops straight into a CRM.** Six columns, one row per domain, consistent key names, null where a platform is absent. There is no nested structure to flatten, no array to unwind and no post-processing step between the export and the import. That matters when the person consuming the data is a sales operations analyst rather than an engineer.

***

### 📥 Input

The Website Social Links Extractor takes a single required input: the list of websites you want to scan. The field uses Apify's request list editor, so each entry is an object with a `url` key.

```json
{
  "startUrls": [
    { "url": "https://www.playstation.com/en-us/" },
    { "url": "https://icrush.de" }
  ]
}
```

#### 🔧 Website Social Links Extractor Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `startUrls` | array of objects | ✅ Yes | `[{"url": "https://www.playstation.com/en-us/"}, {"url": "https://icrush.de"}]` | URLs to scrape. Each entry is an object containing a `url` key. Every URL is fetched and scanned for social media profile links. |

#### 💡 Input Examples

**A single website**

```json
{
  "startUrls": [
    { "url": "https://icrush.de" }
  ]
}
```

**A batch of prospect domains for lead enrichment**

```json
{
  "startUrls": [
    { "url": "https://example-agency.com" },
    { "url": "https://example-store.co.uk" },
    { "url": "https://example-saas.io" },
    { "url": "https://example-manufacturer.de" }
  ]
}
```

**A competitor set you re-scan on a schedule**

```json
{
  "startUrls": [
    { "url": "https://competitor-one.com/about" },
    { "url": "https://competitor-two.com/contact" },
    { "url": "https://competitor-three.com" }
  ]
}
```

***

### 📤 Output

Each website produces one JSON object in the dataset. Below is a real record from an actual run.

```json
{
  "scrapedUrl": "https://icrush.de",
  "facebook": "https://www.facebook.com/icrushjewelry/",
  "instagram": "https://www.instagram.com/icrush_jewelry/",
  "youtube": "https://www.youtube.com/@icrush_jewelry"
}
```

Note what is absent as much as what is present. This site links to Facebook, Instagram and YouTube but not to Twitter, so no `twitter` value is returned — and because the page was fetched and parsed successfully, there is no `error` value either. A record for a website that could not be reached would carry `scrapedUrl` and `error` instead.

#### 🧾 Website Social Links Extractor Output Fields

| Field | Type | Description |
|---|---|---|
| `scrapedUrl` | string | null | The URL of the website that was scanned. |
| `facebook` | string | null | Facebook profile or page URL found on the site. |
| `twitter` | string | null | Twitter/X profile URL found on the site. |
| `instagram` | string | null | Instagram profile URL found on the site. |
| `youtube` | string | null | YouTube channel URL found on the site. |
| `error` | string | null | Error message, if the item failed to process. |

A missing platform field means the scanned page contained no link to that network. That is a finding in its own right, not a failure — "this brand has no Instagram presence on its homepage" is often the exact insight a social audit is looking for.

***

### 💻 How to Use the Website Social Links Extractor (Step by Step)

#### Step 1: Assemble Your Website URL List

Start with the domains you want to scan. These typically come from a CRM export, a prospecting tool, a conference exhibitor list, a directory scrape or an industry association member page. The social links extractor accepts full URLs, so make sure each entry includes the protocol (`https://`). If your source data holds bare domains, prefix them before submission — a spreadsheet formula handles thousands of rows in one pass.

#### Step 2: Choose the Right Page Per Domain

You can point the scraper at any page on a site, and that choice matters. Homepages are the safest default because most brands put their social icon strip in the global footer, which renders on every page. If a particular company hides its social links elsewhere, submitting the `/contact`, `/about` or `/connect` page instead usually surfaces them. When you are unsure, submit both the homepage and the contact page as separate entries and reconcile the two rows afterwards.

#### Step 3: Configure the Input

Open the actor in the Apify Console and go to the **Input** tab. The `startUrls` field renders as a request list editor where you can add entries one at a time, paste a block of URLs, or upload them. If you prefer working in raw JSON, switch to the JSON editor and supply the object structure shown in the Input section above, with each URL wrapped as `{ "url": "..." }`.

#### Step 4: Run the Social Links Scraper

Click **Start** and watch the log. The actor works through the list, fetching each website and scanning its HTML for social media profile links. Because extraction is HTTP-based rather than browser-based, the log stays readable and progress moves quickly — you see results accumulating per URL rather than waiting through browser startup cycles.

#### Step 5: Review the Dataset Preview

When the run finishes, open the **Storage → Dataset** tab. The preview table shows one row per website with all six fields as columns. Sort by the `error` column first to isolate any URLs that failed, then scan the four platform columns to see your coverage rate at a glance. A quick count of non-empty `instagram` values, for example, immediately tells you what share of your prospect list runs an Instagram presence.

#### Step 6: Export the Social Profile Data

Use the export button to download the dataset as JSON, CSV, Excel, XML or HTML. CSV and Excel are the natural choices here because the schema is already flat — six columns map directly onto a CRM import template or a spreadsheet the sales team will actually open. JSON is the better option when the data is feeding a script or an API call.

#### Step 7: Automate with Schedules and Webhooks

For ongoing monitoring, attach an Apify schedule so the same domain list is re-scanned weekly or monthly. Brands launch new channels, retire old ones and change handles more often than most teams realise. Pair the schedule with a webhook that fires on run success to push fresh records into your own system automatically, and compare each run against the last to catch social presence changes as they happen.

***

### 🔌 API Access & Integrations

Run the social links extractor directly from the Apify API and receive the dataset items back in a single synchronous call.

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~website-social-links-extractor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [
      { "url": "https://icrush.de" },
      { "url": "https://www.playstation.com/en-us/" }
    ]
  }'
```

The equivalent run from Python using the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "startUrls": [
        {"url": "https://icrush.de"},
        {"url": "https://www.playstation.com/en-us/"},
    ]
}

run = client.actor("scrapers-hub/website-social-links-extractor").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("error"):
        print(item["scrapedUrl"], "→ failed:", item["error"])
        continue
    print(item["scrapedUrl"])
    for network in ("facebook", "twitter", "instagram", "youtube"):
        if item.get(network):
            print(f"  {network}: {item[network]}")
```

Beyond the API, the actor connects to Zapier, Make, Google Sheets, Slack and generic HTTP webhooks, so extracted social profile URLs can flow straight into your CRM, your outreach sequencer, a shared spreadsheet or a notification channel without any custom glue code.

***

### 💡 Best Use Cases for Social Links Data

#### 🎯 B2B Lead Generation and Prospect Enrichment

Sales teams routinely work from lists of company domains with no contact context attached. Feeding those domains through the social links extractor returns `facebook`, `twitter`, `instagram` and `youtube` URLs per prospect, giving reps a social touchpoint alongside the cold email. Knowing that a target actively runs an Instagram account changes the opening line of an outreach message, and knowing they run none at all is equally useful qualifying information.

#### 🗂️ CRM Data Hygiene and Record Enrichment

Social media fields in a CRM decay quietly — handles change, pages get merged, channels get abandoned. Re-scanning your account list on a schedule and matching `scrapedUrl` back to the account record lets you refresh the Facebook, Twitter, Instagram and YouTube fields in bulk. Rows where a previously populated platform now returns nothing flag accounts whose social presence has changed, which is often an early signal about the business itself.

#### 📊 Competitor Social Presence Audits

Marketing teams need to know where competitors actually invest their attention. Run a competitor set through the extractor and the pattern is immediate: which brands maintain a `youtube` channel, which have quietly dropped `twitter`, which lead with `instagram`. Because the output is one row per domain, the entire competitive landscape fits into a single comparison table rather than a folder of manual screenshots.

#### 🤝 Agency Prospecting and Pitch Preparation

Social media agencies pitch better when they arrive with evidence. Scanning a list of target companies surfaces exactly which networks each one is present on and which they are missing. A prospect with a strong `facebook` and `instagram` presence but no `youtube` link is a concrete, specific pitch — a video content gap you can name in the first meeting, backed by data you gathered before the call.

#### 📣 Influencer and Brand Partnership Vetting

Before committing to a partnership, you need the counterparty's real, official channels rather than whatever a search engine surfaces first. Because the `instagram`, `youtube`, `facebook` and `twitter` URLs come from the brand's own website, they carry a level of verification that a search result does not — these are the accounts the company itself points customers toward, which is exactly what you want when checking for impersonation or abandoned handles.

#### 🔍 M\&A Screening and Due Diligence

When evaluating a portfolio of acquisition targets, social presence is a cheap proxy for marketing maturity and customer engagement. Running the full target list through the social links extractor produces a consistent comparison set in minutes, and the `error` field doubles as a technical signal — a target whose website cannot be fetched reliably is telling you something about the state of its digital infrastructure.

#### 🧹 Directory Building and Data Quality Auditing

If you maintain a directory, marketplace or member listing, the social fields inevitably drift out of date. Scheduling a periodic run against every listed `scrapedUrl` and comparing the returned platform URLs against your stored values produces a precise diff of what needs updating. Rows returning an `error` identify listings whose websites have gone offline entirely — a data quality problem worth catching before your users do.

***

### ⚙️ Tips for Better Social Links Extraction Results

- **Always include the protocol.** Submit `https://example.com`, not `example.com`. Bare domains are a common cause of failed rows, and prefixing them in bulk takes one spreadsheet formula.
- **Prefer homepages and contact pages.** Social icon strips almost always live in the global footer, which renders on the homepage. When a homepage returns nothing, the `/contact` or `/about` page is the next best target.
- **Deduplicate and normalise before you submit.** The same company frequently appears as `example.com`, `www.example.com` and `example.com/en`. Collapsing those variants first avoids three rows for one business and keeps your coverage statistics honest.
- **Treat a null platform as a finding, not a bug.** An empty `instagram` value usually means the site genuinely does not link to Instagram. That is real, reportable information — resist the urge to chase it as an extraction failure without checking the page source first.
- **Batch in manageable chunks.** A few hundred to a couple of thousand URLs per run keeps logs readable and makes it straightforward to trace an anomaly back to a specific batch. Very large lists are better split across several scheduled runs.
- **Filter on `error` immediately after every run.** Sorting the dataset by that column instantly separates clean results from the retry queue, and it takes seconds compared to spot-checking rows by hand.

***

### 🛠️ Troubleshooting

**Why did a website return no social links at all?**
The most common reason is that the page genuinely does not link to any social profile — some corporate and B2B sites deliberately keep them off the main site. The second most common reason is that you scanned a page without the global footer, such as a landing page or a checkout step. Try the homepage or the contact page, and view the page source to confirm whether the links exist in the served HTML.

**Why is the `twitter` field empty when I know the brand has an account?**
The social links extractor reports what the scanned website links to, not what exists elsewhere on the internet. A brand can maintain an active Twitter/X account and simply not link to it from the page you submitted — many sites dropped their Twitter icon from the footer without closing the account.

**A URL returned an `error` value. What does that mean?**
The `error` field carries the reason the specific website could not be processed — an unreachable host, a connection timeout, a malformed URL or a server rejecting the request. Check first that the URL is publicly reachable in a normal browser and that the protocol is included, then re-submit just the failed entries as a smaller retry batch.

**Some social links appear to be missing on JavaScript-heavy sites.**
This actor fetches the served HTML directly rather than executing a browser. If a site injects its footer or social icon strip purely through client-side JavaScript after page load, those links will not be present in the HTML the scraper receives. Sites that server-render their markup — still the large majority of company websites — extract normally.

**The run completed but returned fewer records than URLs I submitted.**
Duplicate entries in `startUrls` and URLs that fail to resolve are the usual explanation. Compare the `scrapedUrl` values in the dataset against your original input list to identify which entries dropped out, then verify those specific links directly in a browser.

***

### ❓ Frequently Asked Questions About Social Links Extraction

**What does the Website Social Links Extractor actually do?**
It takes a list of website URLs, fetches each page, and returns the Facebook, Twitter, Instagram and YouTube profile URLs that the site links to, along with the source URL and an error message when a page cannot be processed.

**Which social platforms does this social links extractor support?**
Four: Facebook, Twitter/X, Instagram and YouTube. Those are the only platform fields in the output schema.

**What input does the actor require?**
A single required field, `startUrls`, containing an array of objects each with a `url` key. That is the only input property.

**Can I scan multiple websites in one run?**
Yes — that is the primary use case. The `startUrls` array accepts as many entries as you want to submit, and each website is processed independently so one failure never affects the rest.

**Do I need to write selectors or configure anything per website?**
No. The same detection logic is applied to every URL you submit, so there is nothing to configure and nothing to maintain when a site changes its design.

**Does this social links scraper use a headless browser?**
No. It uses direct HTTP requests with a fast HTML selector library, which keeps runs quick and light. The trade-off is that content injected purely by client-side JavaScript after page load is not visible to it.

**What happens when a website has no social links?**
You still get a record containing the `scrapedUrl`, simply with no platform values populated. An absent social presence is recorded as an absence rather than dropped from the dataset.

**How is the `error` field different from a failed run?**
The `error` field is per record. A single unreachable website populates its own `error` value while the rest of your URL list processes normally, so a large batch never fails wholesale because of a handful of bad domains.

**Can I schedule the social links extractor to run automatically?**
Yes. Attach an Apify schedule to re-scan the same domain list on any cadence, and add a webhook so downstream systems are notified the moment a run finishes and fresh records land.

**Is there a limit on how many URLs I can submit?**
The input schema imposes no fixed cap. Practical limits come from run duration and memory, so very large lists are best divided across several runs.

**What export formats are available for the social profile data?**
Apify datasets export to JSON, JSONL, CSV, Excel, XML, HTML and RSS. CSV and Excel suit CRM imports because the schema is already flat; JSON suits scripted pipelines.

**Should I submit the homepage or a deeper page?**
Start with the homepage, since the footer that carries social icons renders site-wide on most builds. If a homepage returns nothing useful, submit the contact or about page for that domain as a second entry.

**Will it find social links placed anywhere on the page?**
The scraper scans the fetched page's HTML, so links found in the header, the footer, a contact block or the body content are all candidates — it is not restricted to one region of the page.

**Can I use this for lead generation and CRM enrichment?**
Yes, that is one of the most common applications. Match `scrapedUrl` back to your account records and populate the four platform fields in bulk, then re-run periodically to keep them current.

**Does the actor cost anything per result?**
No. It carries no per-result charge — you consume only standard Apify platform compute for the run itself.

***

### 🆘 Support & Feedback

Found a bug, hit an edge case, or seen a website whose social links are not being detected? Open a ticket on the actor's **Issues** tab and include the exact URL along with a short note about what you expected to see. Reproducible reports with a specific failing URL get resolved fastest.

Need a customised version — additional platforms, deeper crawling across multiple pages per domain, contact detail extraction alongside social profiles, or a private actor built around your own prospect pipeline? Email **scraperhubapi@gmail.com** and describe what you are trying to build.

If the Website Social Links Extractor saves you time, please leave a review on the Apify Store. Ratings and written feedback genuinely influence which improvements get built next.

***

### ⚖️ Disclaimer

The Website Social Links Extractor collects **publicly available data** only — social media profile URLs that a website publishes openly on pages any visitor can reach without logging in or bypassing an access control. It does not attempt to defeat authentication, and it does not access content behind a login.

You are responsible for how you use the extracted social profile data. Before running the social links extractor at scale, review each target website's Terms of Service and robots.txt and respect the restrictions they set out. Sensible request volumes and reasonable scheduling are part of scraping responsibly, and the same applies to the terms of the social platforms whose profile URLs you collect.

Where the websites you scan belong to sole traders, freelancers or individuals, the resulting social profile URLs may constitute personal data. If you process such data relating to people in the EU, UK or other regulated jurisdictions, you must comply with the GDPR and equivalent privacy laws — establish a lawful basis, honour data subject rights, collect only what you need, and delete what you no longer use. This is particularly relevant when social links data feeds outreach and marketing workflows, which carry their own consent requirements under laws such as the GDPR and PECR.

If you believe data collected by this actor relates to you and you would like it removed, contact **scraperhubapi@gmail.com** with the relevant details and we will action the request.

# Actor input Schema

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

URLs to scrape

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.playstation.com/en-us/"
    },
    {
      "url": "https://icrush.de"
    }
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

Records scraped by Website Social Links Extractor, stored in the run's default dataset.

# 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://www.playstation.com/en-us/"
        },
        {
            "url": "https://icrush.de"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/website-social-links-extractor").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://www.playstation.com/en-us/" },
        { "url": "https://icrush.de" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/website-social-links-extractor").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://www.playstation.com/en-us/"
    },
    {
      "url": "https://icrush.de"
    }
  ]
}' |
apify call scrapers-hub/website-social-links-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/website-social-links-extractor"
        }
    }
}

```

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/lD5hYHBCdwVSTWkWm/builds/hmDG6aHDpHOfzT8l3/openapi.json