# Best Linkedin Phone Number Scraper (`scrapers-hub/best-linkedin-phone-number-scraper`) Actor

Best LinkedIn Phone Number Scraper extracts publicly listed phone numbers by keyword and country - phone number, dial code, profile title, description, URL and source type. 📞 Built for B2B sales prospecting, recruiting and CRM enrichment.

- **URL**: https://apify.com/scrapers-hub/best-linkedin-phone-number-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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

## 📞 Best LinkedIn Phone Number Scraper – B2B Contact Data & Lead Generation Extractor

The **LinkedIn Phone Number Scraper** finds publicly visible phone numbers associated with LinkedIn profiles, company pages, posts and Pulse articles by running targeted search-engine queries and validating every match against the international numbering plan. Give it a set of job titles or industry keywords plus a target country, and it returns a clean dataset of contact records — each with the phone number in E.164 format, the LinkedIn URL it came from, the page title, the surrounding snippet text, and the country and dial code it was matched against.

This LinkedIn phone number scraper is aimed at B2B lead generation, sales prospecting and recruitment sourcing teams who need direct dial data rather than another list of generic info@ mailboxes. Rather than scraping LinkedIn's own interface, it queries indexed public search results scoped to LinkedIn domains, then applies the `phonenumbers` library — the same validation logic used across the telecoms industry — so what lands in your dataset is a genuinely dialable number rather than an order reference or a date that happens to look numeric.

***

### 📊 What Data Can You Extract with This LinkedIn Phone Number Scraper?

Each dataset row is one validated, deduplicated phone number together with the context that produced it. Grouped by purpose, the real output fields look like this.

| Category | Fields | What You Get |
|---|---|---|
| ☎️ Contact data | `phone_number` | The validated number in E.164 international format, ready for dialers and CRM import |
| 🌍 Geographic targeting | `country`, `dial_code` | The country the search targeted and its international dial code |
| 🔗 Source attribution | `url` | The LinkedIn URL where the number was surfaced, so every record is traceable |
| 🏷️ Page context | `title`, `description` | The page title and the surrounding snippet text that contained the number |
| 🔍 Query provenance | `keyword` | The search term from your input that produced this particular result |
| 🗂️ Record classification | `source_type` | Whether the match came from profiles, company pages, posts, Pulse articles, or all of them |

The `description` field is the one that turns a phone list into a usable prospecting list. Because it carries the snippet text surrounding the number, it usually contains the role, the company, or the context in which the person published their contact details — enough qualification signal to prioritise a call list before anyone picks up a phone.

***

### 🌟 Key Features of the LinkedIn Phone Number Scraper

| Feature | Description |
|---|---|
| ✅ Real number validation | Every candidate is parsed with the `phonenumbers` library against the target country's numbering plan, so malformed strings are discarded |
| 🌐 E.164 normalisation | Numbers are output in the international E.164 format, the standard most CRMs, dialers and telephony APIs expect |
| 🗺️ 190+ country targeting | A built-in mapping covers international dial codes and ISO country codes for the vast majority of world countries |
| 🎯 Four LinkedIn source types | Scope your search to profiles, company pages, posts or Pulse articles — or search across all of them at once |
| 🔁 Automatic deduplication | A running set of seen numbers prevents the same contact appearing twice, even across different keywords |
| 💾 Resumable progress | Keyword position and seen numbers are persisted to the key-value store, so an interrupted run resumes where it stopped |
| 🔀 Multi-keyword batching | Supply an array of job titles or industry terms and the scraper works through them sequentially in one run |
| 📤 Incremental dataset pushes | Every validated number is pushed the moment it is found, so partial results are available while the run continues |
| 🌍 Automatic proxy rotation | Search requests are routed through Apify's proxy network automatically, with fresh proxies retried on blocked pages |

***

### 🚀 Why Choose This LinkedIn Phone Number Scraper?

**Validated numbers, not regex guesses.** Naive phone extraction with a regular expression produces enormous noise: postcodes, invoice numbers, dates and product SKUs all match loosely. This LinkedIn phone number scraper runs every candidate through `phonenumbers` with the target country's ISO code, which applies the actual national numbering rules. Numbers that cannot exist in that country are dropped before they ever reach your dataset.

**Full provenance on every record.** A phone number with no context is close to useless for outreach. Each row keeps the `url`, `title`, `description` and originating `keyword`, so a sales rep can see who they are calling, what the person does, and where the number was published — before the conversation starts.

**Search scoping that matches your motion.** Personal direct dials cluster on profiles; switchboard and department numbers cluster on company pages; conference and event numbers often appear in posts. The `sourceRegion` control lets you point the scraper at the surface that matches your outreach strategy rather than taking whatever comes.

**Built to survive long runs.** Search engines throttle. This scraper detects empty and blocked result pages, retries them with a fresh proxy, stops cleanly after repeated blocks rather than burning compute, and checkpoints its position so a restarted run does not redo completed work.

***

### 📥 Input

The LinkedIn phone number scraper takes your search keywords, a target country, a result cap and a LinkedIn source scope.

```json
{
  "searchTerms": ["CEO", "Head of Procurement", "Operations Director"],
  "country": "United States (+1)",
  "maxPhoneNumbers": 20,
  "sourceRegion": "All"
}
```

#### 🔧 LinkedIn Phone Number Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchTerms` | array | string | ❌ No | `["CEO"]` | Job titles, industries or company terms to search for. Accepts a single string or an array; each term is processed in turn. |
| `country` | string | ❌ No | `"United States (+1)"` | Target country with its dial code. Determines both the dial code appended to the query and the ISO code used for number validation. |
| `maxPhoneNumbers` | integer | ❌ No | `20` | Maximum number of unique phone numbers to collect before the run stops. Free Apify accounts are capped at 100 per run. |
| `sourceRegion` | string | ❌ No | `"All"` | Which LinkedIn surface to search: `All`, `Profile`, `Company`, `Posts` or `Pulse`. |

#### 💡 Input Examples

**Executive prospecting in the United Kingdom**

```json
{
  "searchTerms": ["Managing Director", "Chief Financial Officer"],
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 50,
  "sourceRegion": "Profile"
}
```

**Company switchboard collection for an industry segment**

```json
{
  "searchTerms": ["logistics company", "freight forwarding"],
  "country": "Germany (+49)",
  "maxPhoneNumbers": 100,
  "sourceRegion": "Company"
}
```

**Recruitment sourcing from posts and articles**

```json
{
  "searchTerms": ["hiring backend engineer", "we are hiring devops"],
  "country": "India (+91)",
  "maxPhoneNumbers": 40,
  "sourceRegion": "Posts"
}
```

***

### 📤 Output

Each dataset item is one unique, validated phone number with its full source context.

```json
{
  "keyword": "Head of Procurement",
  "title": "Jane Doe - Head of Procurement - Northwind Logistics | LinkedIn",
  "description": "Head of Procurement at Northwind Logistics. Direct contact: +1 415 555 0142 for supplier enquiries and tender submissions.",
  "url": "https://www.linkedin.com/in/example-profile",
  "phone_number": "+14155550142",
  "country": "United States",
  "dial_code": "+1",
  "source_type": "Profile"
}
```

#### 🧾 LinkedIn Phone Number Scraper Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | null | Keyword that produced this item. |
| `title` | string | null | Title of the item — the page title of the LinkedIn result. |
| `description` | string | null | Long-form description text — the search snippet in which the number was found. |
| `url` | string | null | Canonical URL of the scraped item. |
| `phone_number` | string | null | Phone number found for the item, normalised to E.164 format. |
| `country` | string | null | Country targeted for this search. |
| `dial_code` | string | null | Dial code of the item. |
| `source_type` | string | null | Source type of the item — the LinkedIn surface the result came from. |

***

### 💻 How to Use the LinkedIn Phone Number Scraper (Step by Step)

#### Step 1: Define Your Ideal Customer Profile as Keywords

The quality of your output is decided almost entirely at this step. Broad terms such as "CEO" return an enormous but unfocused pool; specific terms such as "Head of Clinical Operations" or "freight forwarding manager" return fewer results with far higher relevance. Build an array combining seniority, function and industry vocabulary — the phrases your prospects would actually use to describe themselves on a LinkedIn headline. Ten well-chosen terms usually outperform a single generic one.

#### Step 2: Select the Target Country

The `country` value does double duty. Its dial code is appended to the search query, which biases results toward pages that display numbers in that format, and its ISO code is passed to the validator so numbers are checked against that country's national numbering plan. This means country selection is not cosmetic: choosing the wrong country will cause valid numbers to be rejected as invalid. Run one country per job rather than mixing markets in a single run.

#### Step 3: Choose the Right Source Type

Set `sourceRegion` according to what you actually want to dial. `Profile` scopes the query to personal profile URLs and is the best fit for direct dials and individual outreach. `Company` scopes to company pages and tends to yield switchboards, sales lines and regional office numbers. `Posts` and `Pulse` scope to shared updates and long-form articles, where people often publish event, recruitment or enquiry numbers. `All` searches across profiles, company pages and posts together.

#### Step 4: Set a Realistic Result Cap

`maxPhoneNumbers` controls when the run stops. Start modestly — the default of 20 is a sensible first pass to check that your keywords produce the kind of records you want. Once you are satisfied with the shape of the output, raise the cap for a production run. Note that on a free Apify account the scraper enforces a maximum of 100 unique numbers per run regardless of what you request, and it logs clearly when that limit is applied.

#### Step 5: Run the Scraper and Watch the Log

Start the actor and follow the log. It reports each keyword as it begins, each search page as it fetches, and every number as it is found and pushed. The log also surfaces its own defensive behaviour: pages that returned no results, retries with a fresh proxy, and the point at which it stops a keyword after repeated blocks or three consecutive pages yielding no new numbers. Reading this log tells you whether a disappointing run was a keyword problem or a blocking problem.

#### Step 6: Review, Deduplicate and Qualify Before Dialling

The scraper deduplicates on the E.164 number within a run, but you should still qualify before outreach. Read the `description` alongside the `title` to confirm the number belongs to the person or organisation you think it does — snippets sometimes contain a number that belongs to a different entity mentioned on the same page. Cross-reference against your CRM to drop existing contacts and anyone on a suppression or do-not-call list.

#### Step 7: Export and Load into Your Sales Stack

Export the dataset as CSV or JSON from the Console, or pull it through the API. Because `phone_number` is already in E.164, it imports directly into most CRMs, dialers and telephony platforms without reformatting. Map `url` to a source or lead-origin field so every contact record keeps a link back to the page it came from — invaluable when someone asks where a number was obtained.

***

### 🔌 API Access & Integrations

Run the LinkedIn phone number scraper synchronously and receive dataset items in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~best-linkedin-phone-number-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerms": ["Head of Procurement", "Supply Chain Director"],
    "country": "United Kingdom (+44)",
    "maxPhoneNumbers": 50,
    "sourceRegion": "Profile"
  }'
```

The same run in Python using the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "searchTerms": ["Head of Procurement", "Supply Chain Director"],
    "country": "United Kingdom (+44)",
    "maxPhoneNumbers": 50,
    "sourceRegion": "Profile",
}

run = client.actor("scrapers-hub/best-linkedin-phone-number-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(
        item.get("phone_number"),
        item.get("source_type"),
        item.get("keyword"),
        item.get("url"),
    )
```

The actor also connects to Zapier, Make, Google Sheets, Slack and any custom endpoint through Apify webhooks, so new contact records can flow straight into your CRM, a shared spreadsheet, or a sales notification channel as soon as a run finishes.

***

### 💡 Best Use Cases for LinkedIn Phone Number Data

#### 📈 Outbound B2B Sales Prospecting

Direct dials convert at a different rate to generic inbox addresses. Combining `phone_number` with the `title` and `description` context gives a rep enough to open a call with something specific rather than a cold script. Scoping `sourceRegion` to `Profile` and using precise seniority keywords produces the tightest lists for this motion.

#### 🧑‍💼 Recruitment and Candidate Sourcing

Technical recruiters working hard-to-fill roles frequently need to reach candidates outside the platform's messaging limits. Searching role-specific `searchTerms` with `sourceRegion` set to `Posts` surfaces people who have publicly shared contact details, often in the context of availability or a job change, with the `description` giving the surrounding signal.

#### 🏢 Account-Based Marketing Contact Enrichment

ABM programmes stall when target accounts have thin contact coverage. Running industry and function keywords with `sourceRegion` set to `Company` fills in switchboard and departmental numbers, while the `url` field ties each number back to the specific company page for accurate account mapping.

#### 🌍 International Market Entry Research

Expanding into a new market means building a contact base from nothing. Because the `country` input drives both query targeting and number validation, you can run the same keyword set across several markets in sequence and compare the `dial_code` distribution and record volume to gauge how reachable each market's decision-makers actually are.

#### 🤝 Partner, Reseller and Supplier Discovery

Channel and procurement teams need to reach organisations rather than individuals. Company-scoped searches on industry vocabulary surface published business lines, and the `description` snippet usually indicates whether the number is a sales, support or general enquiry route — useful for routing the first approach correctly.

#### 📣 Event and Conference Outreach

Speakers, sponsors and organisers routinely publish contact numbers in posts and Pulse articles around an event. Setting `sourceRegion` to `Posts` or `Pulse` with event-related `searchTerms` captures these time-sensitive records, with `keyword` letting you attribute each contact back to the specific event or campaign that surfaced it.

#### 🧹 CRM Data Enrichment and Gap Filling

Existing CRM records frequently carry an email but no phone. Running keyword searches matched to your known accounts and joining results on the LinkedIn `url` lets you fill phone gaps on existing records, with `source_type` documenting the provenance of each newly added number for compliance and audit purposes.

***

### ⚙️ Tips for Better LinkedIn Phone Number Scraping Results

- **Prefer specific keywords over broad ones.** "Head of Clinical Operations" produces a smaller but dramatically more relevant set than "manager". Combine role, seniority and industry vocabulary in each term.
- **Match the country to the numbers you actually want.** Validation uses the selected country's ISO code, so numbers belonging to other countries in the same snippet will be rejected. Run one market per job.
- **Use `Profile` for people and `Company` for organisations.** Mixing them under `All` dilutes both. Decide whether you are building a direct-dial list or an organisational switchboard list before you run.
- **Start small, then scale the cap.** A run with `maxPhoneNumbers` set to 20 costs little and tells you within minutes whether your keyword set produces relevant records. Only then raise the limit.
- **Watch the log for blocking signals.** Repeated empty result pages followed by proxy retries mean the search surface is throttling. Re-running later, or with fewer keywords per job, generally recovers throughput.
- **Always verify before dialling.** Snippets can contain a number belonging to a different entity mentioned on the same page. Read `title` and `description` together and treat the number as a lead, not a confirmed fact.
- **Run in several passes rather than one giant job.** Progress is checkpointed, but shorter, focused runs are easier to evaluate and let you adjust keywords between passes instead of discovering a bad keyword set after an hour.

***

### 🛠️ Troubleshooting

**Why did the run finish with fewer numbers than I requested?**
Two reasons dominate. Either the keyword and country combination genuinely has few publicly published numbers indexed, or the search surface began blocking and the scraper stopped that keyword defensively. The log distinguishes these clearly: it reports a shortfall summary at the end and logs blocked pages as they happen. Broadening the keyword list or trying a different `sourceRegion` is the usual fix.

**Why did the scraper stop after 100 numbers when I asked for more?**
Free Apify accounts are capped at 100 unique phone numbers per run. The scraper logs this limit explicitly when it applies it, showing both what you requested and what was enforced. Paid accounts are not subject to this cap.

**Why are some numbers clearly not for the person on the profile?**
The scraper extracts numbers from the search snippet text surrounding a LinkedIn result. If a page mentions a partner company, an event line or a third party, that number can be captured too. Reading `description` alongside `title` before outreach is the correct safeguard — treat records as leads requiring verification.

**Why did a keyword return nothing at all?**
Either no indexed LinkedIn pages match that phrase combined with the country dial code, or the search returned pages the scraper could not parse. It retries empty pages with a fresh proxy before giving up, and abandons a keyword after three consecutive blocked pages. Rephrasing the keyword in the language and vocabulary used in the target market often helps.

**Why do some valid-looking numbers never appear in the output?**
Numbers are validated against the ISO code of the country you selected. A German number in a snippet will be rejected on a United States run because it is not a valid US number. Set `country` to match the market whose numbers you actually want, and run additional markets as separate jobs.

***

### ❓ Frequently Asked Questions About LinkedIn Phone Number Scraping

**What does this LinkedIn phone number scraper actually do?**
It runs targeted search-engine queries scoped to LinkedIn domains, reads the resulting page titles and snippets, extracts any phone numbers present, validates each one against the target country's numbering plan, and pushes unique validated numbers to an Apify dataset alongside the source URL and context.

**Does it log into LinkedIn or scrape the LinkedIn interface directly?**
No. It queries publicly indexed search results scoped to LinkedIn URLs. It does not authenticate, does not access member-only content, and does not interact with LinkedIn's own application.

**How accurate are the phone numbers it returns?**
Every number is parsed and validated with the `phonenumbers` library against the selected country's national numbering rules and output in E.164 format, which removes malformed and impossible numbers. Validity is not the same as attribution, however — always confirm the number belongs to the intended contact by reading the `title` and `description` before dialling.

**Which countries does the LinkedIn phone number scraper support?**
It carries a built-in mapping of dial codes and ISO country codes covering more than 190 countries. Select the target market in the `country` input using the country name and dial code format shown in the input examples.

**How many phone numbers can I collect in one run?**
Set the target with `maxPhoneNumbers`. Free Apify accounts are limited to 100 unique numbers per run, a cap the scraper applies and logs automatically. Paid accounts can request higher limits.

**What is the difference between the Profile, Company, Posts and Pulse source types?**
Each scopes the search to a different LinkedIn URL pattern. `Profile` targets personal profiles and yields direct dials; `Company` targets company pages and yields business lines; `Posts` targets shared updates; `Pulse` targets long-form articles. `All` searches profiles, company pages and posts together.

**Can I search multiple job titles in one run?**
Yes. Pass an array to `searchTerms` and each term is processed in sequence, with the originating term recorded in the `keyword` field of every resulting row so you can attribute results back to the query that found them.

**Are duplicate phone numbers removed?**
Yes. The scraper maintains a set of numbers already seen during the run, keyed on the normalised E.164 value, so the same number is never pushed twice even if it appears under several different keywords.

**What format are the phone numbers returned in?**
E.164 international format — a leading plus sign followed by country code and subscriber number, with no spaces or punctuation. This is the format most CRMs, dialers and telephony APIs expect for direct import.

**Does the scraper use proxies, and can I configure them?**
It routes search requests through Apify's proxy network automatically and retries blocked pages with a fresh proxy. Proxy settings are not exposed as an input field, so there is nothing for you to configure.

**Can I resume a run that was interrupted?**
Yes. The scraper checkpoints its keyword position and its set of seen numbers to the key-value store after every result, so a restarted run continues from where it stopped rather than repeating completed work.

**Is scraping phone numbers from LinkedIn search results legal?**
The actor collects only information already published publicly and indexed by search engines. Whether your particular use is lawful depends on your jurisdiction, your purpose, and the applicable privacy and marketing regulations. Phone numbers belonging to individuals are personal data under the GDPR and similar frameworks, and telephone marketing is separately regulated in most countries. Take your own legal advice before running outreach campaigns.

**Can I use these numbers for cold calling and SMS marketing?**
Only where you have a lawful basis to do so and after screening against the relevant do-not-call or telephone preference registers in the target market. Many jurisdictions require prior consent for automated calls and marketing SMS, and penalties for non-compliance are substantial. This is your responsibility, not the actor's.

**How do I export the scraped LinkedIn phone number data?**
From the Apify Console Dataset tab you can download JSON, JSONL, CSV, Excel, XML or RSS. Programmatically, use the dataset API or the `apify_client` iteration shown in the API section above.

**Can I schedule the LinkedIn phone number scraper to run automatically?**
Yes. Apify schedules can trigger the actor on any cron expression, and webhooks can push results into your CRM or notify a Slack channel when a run completes.

***

### 🆘 Support & Feedback

Hit an error, seeing lower yields than expected, or found a country that validates incorrectly? Open a ticket on the **Issues** tab of this actor with your input configuration and the run ID. That is the quickest path to a fix and leaves a public record other users can benefit from.

Need something tailored? Custom keyword strategies, additional source scopes, direct CRM integration, or a private variant tuned to a specific market are all possible. Email **scraperhubapi@gmail.com** describing the outcome you need and the markets you are targeting.

If this LinkedIn phone number scraper helps your pipeline, please leave a review on the actor page. Ratings and written feedback directly shape what gets built next.

***

### ⚖️ Disclaimer

This LinkedIn phone number scraper collects only information that is already published publicly and indexed by search engines. It does not authenticate to LinkedIn, does not access member-only or connection-restricted content, and does not bypass any access control, paywall or technical protection measure.

Phone numbers belonging to identifiable individuals are personal data under the GDPR, the UK GDPR, the CCPA and comparable privacy laws. If you use this actor, you act as the data controller for that processing. You must establish and document a lawful basis, apply data minimisation, provide the transparency information data subjects are entitled to, honour access, objection and erasure requests, and retain records no longer than is necessary for your stated purpose. Legitimate interests is not an automatic justification for bulk contact collection.

Telephone and SMS marketing is separately regulated in most jurisdictions. Before contacting anyone, screen your list against the applicable do-not-call or telephone preference registers, respect consent requirements for automated dialling and marketing messages, and identify yourself properly on every call. You are also responsible for complying with the terms of service of LinkedIn and of any search engine whose results contribute to your run, and for ensuring your use does not breach anti-spam legislation in the recipient's country.

If you believe data collected through this actor relates to you and should be removed, or you have any other privacy concern about a specific record, contact **scraperhubapi@gmail.com** and the request will be reviewed promptly.

# Actor input Schema

## `country` (type: `string`):

Select the country to target for Google search results.

## `maxPhoneNumbers` (type: `integer`):

Stop scraping after this many phone numbers are found.

## `searchTerms` (type: `array`):

Enter keywords to find LinkedIn profiles/companies (e.g., 'CEO', 'Marketing Managers', 'Tech Startups').

## `sourceRegion` (type: `string`):

Select the type of LinkedIn page to target.

## Actor input object example

```json
{
  "country": "United States (+1)",
  "maxPhoneNumbers": 20,
  "searchTerms": [
    "ceo",
    "marketing manager",
    "founder"
  ],
  "sourceRegion": "All"
}
```

# Actor output Schema

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

Records scraped by Best Linkedin Phone Number Scraper, 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 = {
    "searchTerms": [
        "ceo",
        "marketing manager",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/best-linkedin-phone-number-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 = { "searchTerms": [
        "ceo",
        "marketing manager",
        "founder",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/best-linkedin-phone-number-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "ceo",
    "marketing manager",
    "founder"
  ]
}' |
apify call scrapers-hub/best-linkedin-phone-number-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/best-linkedin-phone-number-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/RiCATQ3zWjKeYtqLi/builds/o78VNYUqaeg0aKqXq/openapi.json