# Mawsool - Verified Email to LinkedIn Lookup (`oday/mawsool-email-linkedin-lookup`) Actor

Turn emails into confirmed LinkedIn profiles. Mawsool returns exact matches only - real name, headline, URL, company. No guessing. Built for sales, recruiting and CRM enrichment.

- **URL**: https://apify.com/oday/mawsool-email-linkedin-lookup.md
- **Developed by:** [Mawsool Intertaional](https://apify.com/oday) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Mawsool — Verified Email to LinkedIn Profile Lookup

**Turn any email into a confirmed LinkedIn profile — or know with certainty that none exists.**

Powered by **[Mawsool](https://mawsool.tech)**, the AI-powered B2B intelligence platform behind **1 billion+ verified contacts**. This is not a scraper guessing from public pages. This is **verified reverse email lookup** — the same accuracy standard Mawsool uses for enterprise lead generation.

---

### Why teams choose this over generic enrichers

| | Generic tools | **Mawsool (this Actor)** |
|---|---------------|--------------------------|
| Match quality | Often fuzzy / guessed | **Exact matches only** |
| False positives | Common | **Rejected** — uncertain hits return `hasLinkedIn: false` |
| Data freshness | Static databases (months old) | **Real-time verification** |
| Profile fields | Basic or incomplete | **Full profile**: name, headline, URL, photo, company, location |
| Built for | Hobby projects | **Sales, recruiting, CRM, outbound at scale** |

> **If `hasLinkedIn` is `true`, that LinkedIn profile belongs to that email. Period. No guessing.**

---

### What you get in every result

For each email you submit, you receive **all fields from the Mawsool deep-v2 API** as flat, exportable columns:

| Column | Description |
|--------|-------------|
| `email`, `hasLinkedIn`, `matchType`, `method` | Lookup metadata |
| `profileId` | LinkedIn profile identifier |
| `fullName`, `firstName`, `lastName` | Name |
| `headline`, `summary` | Professional headline and bio |
| `linkedinUrl`, `pictureUrl`, `reportProfileUrl` | Profile links |
| `company`, `location` | Current company and location |
| `isPublic`, `localeCountry`, `localeLanguage` | Profile visibility and locale |
| `educationsCount`, `positionsCount`, `skillsCount` | Counts |
| `skills` | Semicolon-separated skill list |
| `educationHistory` | Full education history (JSON string) |
| `positionHistory` | Full work history (JSON string) |
| `checkedAt` | Verification timestamp |

Use the **Enriched contacts** view for CRM export, or **Full profile data** / **All fields** for complete API output. Export as CSV, Excel, or JSON from any view.

When no exact match exists, you get an honest `hasLinkedIn: false` — not a wrong profile.

---

### Who uses this

#### Sales & outbound teams
Enrich cold email lists with **verified LinkedIn URLs** before sending connection requests. Stop wasting time on emails with no professional presence.

#### Recruiters & talent teams
Confirm that a candidate's application email maps to the **real LinkedIn profile** — not a similarly named stranger.

#### RevOps & CRM enrichment
Pipe results into **HubSpot, Salesforce, Pipedrive, or Clay**. Append LinkedIn data to contacts automatically via Apify API, webhooks, Zapier, or Make.

#### Growth & lead scoring
Prioritize leads where email → LinkedIn verification succeeds. Build smarter scoring models on **confirmed** identity data.

#### Data engineers
Batch-process thousands of emails. Export to **JSON, CSV, Excel, or Google Sheets** from Apify datasets.

---

### How to use

#### Input

```json
{
  "emails": [
    "jane.doe@acme.com",
    "john.smith@startup.io"
  ],
  "maxEmails": 100
}
````

| Field | Required | Description |
|-------|----------|-------------|
| `emails` | **Yes** | One or more email addresses to verify |
| `maxEmails` | No | Safety cap per run (default: 100, max: 10,000) |

#### Output — profile found

```json
{
  "email": "jane.doe@acme.com",
  "hasLinkedIn": true,
  "profile": {
    "displayName": "Jane Doe",
    "firstName": "Jane",
    "lastName": "Doe",
    "headline": "VP Sales at Acme Inc",
    "profileUrl": "https://www.linkedin.com/in/janedoe",
    "pictureUrl": "https://...",
    "company": "Acme Inc",
    "location": "New York, NY"
  },
  "checkedAt": "2026-06-28T12:00:00.000Z",
  "success": true,
  "error": null,
  "statusCode": 200
}
```

#### Output — no LinkedIn on this email

```json
{
  "email": "unknown@company.com",
  "hasLinkedIn": false,
  "profile": null,
  "checkedAt": "2026-06-28T12:00:00.000Z",
  "success": true,
  "error": null,
  "statusCode": 200
}
```

***

### Quick start (3 steps)

1. **Add your emails** to the `emails` input field
2. **Click Start** — each email is verified in seconds
3. **Download results** from the dataset tab (JSON / CSV / Excel)

#### Run via API

```bash
apify call oday/mawsool-email-linkedin-lookup \
  --input '{"emails":["prospect@company.com"]}'
```

#### Schedule daily enrichment

Use Apify Scheduler to run this Actor nightly on new CRM exports — fully automated.

***

### Pricing

**Pay per email verified** — one `email-lookup` event per email processed.

| Plan tier | Price per email | Price per 1,000 emails |
|-----------|-----------------|------------------------|
| Free / Starter (Bronze) | $0.002 | **$2.00** |
| Scale (Silver) | $0.0015 | $1.50 |
| Business (Gold) | $0.001 | $1.00 |
| Platinum | $0.0008 | $0.80 |
| Diamond / Enterprise | $0.0006 | $0.60 |

Higher Apify subscription plans automatically unlock lower per-email rates. No Mawsool subscription required on Apify.

***

### Integrations

Works with:

- **Apify API** — programmatic runs at any scale
- **Webhooks** — trigger downstream workflows on completion
- **Zapier & Make** — no-code automation
- **Google Sheets** — one-click export from dataset
- **Your own backend** — poll dataset or use sync API

***

### About Mawsool

[Mawsool](https://mawsool.tech) is a patent-pending B2B lead intelligence platform:

- **1B+ verified global contacts** — 4× the reach of leading competitors
- **98%+ email accuracy** with triple verification
- **Real-time data** — millisecond-accurate, not quarterly-refreshed lists
- **Money-back guarantee** — industry-leading confidence in data quality
- **Global coverage** including MENA markets others miss

This Actor brings Mawsool's enterprise-grade **reverse email verification** to the Apify Store.

**Website:** [mawsool.tech](https://mawsool.tech)\
**Support:** <support@mawsool.tech>

***

### FAQ

**Is this guessing LinkedIn profiles from similar names?**\
No. Only **exact, verified matches** are returned as `hasLinkedIn: true`. Everything else is `false`.

**Can I process thousands of emails?**\
Yes. Use `maxEmails` or split across multiple runs. Apify handles scheduling and API orchestration.

**What if an email has no LinkedIn?**\
You get `hasLinkedIn: false` and `profile: null` — a clean, honest result you can filter on.

**Does this work with personal emails?**\
Yes. If that email has a verified LinkedIn identity, you get the profile. If not, you get a clear no-match.

***

### Limitations

- Exact matches only — fuzzy/uncertain results are reported as not found (by design, for accuracy)
- Requires active Mawsool API capacity on the backend

# Actor input Schema

## `emails` (type: `array`):

Enter work or personal emails. Mawsool checks each one for a confirmed LinkedIn profile — exact matches only, never guessed. Paste a list or upload from CSV.

## `maxEmails` (type: `integer`):

Limit how many emails are processed in one run. Useful for testing or controlling cost.

## Actor input object example

```json
{
  "emails": [
    "jane.doe@acme.com",
    "john.smith@startup.io"
  ],
  "maxEmails": 100
}
```

# Actor output Schema

## `contacts` (type: `string`):

Flat table of verified LinkedIn data per email. Export as CSV or JSON from the dataset.

## `runSummary` (type: `string`):

Counts of processed, found, and failed lookups for this run.

# 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 = {
    "emails": [
        "jane.doe@acme.com",
        "john.smith@startup.io"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("oday/mawsool-email-linkedin-lookup").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 = { "emails": [
        "jane.doe@acme.com",
        "john.smith@startup.io",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("oday/mawsool-email-linkedin-lookup").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 '{
  "emails": [
    "jane.doe@acme.com",
    "john.smith@startup.io"
  ]
}' |
apify call oday/mawsool-email-linkedin-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=oday/mawsool-email-linkedin-lookup",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mawsool - Verified Email to LinkedIn Lookup",
        "description": "Turn emails into confirmed LinkedIn profiles. Mawsool returns exact matches only - real name, headline, URL, company. No guessing. Built for sales, recruiting and CRM enrichment.",
        "version": "1.9",
        "x-build-id": "ZbbrJCZs2WO4g8kBB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/oday~mawsool-email-linkedin-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-oday-mawsool-email-linkedin-lookup",
                "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/oday~mawsool-email-linkedin-lookup/runs": {
            "post": {
                "operationId": "runs-sync-oday-mawsool-email-linkedin-lookup",
                "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/oday~mawsool-email-linkedin-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-oday-mawsool-email-linkedin-lookup",
                "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",
                "required": [
                    "emails"
                ],
                "properties": {
                    "emails": {
                        "title": "Email addresses to verify",
                        "minItems": 1,
                        "type": "array",
                        "description": "Enter work or personal emails. Mawsool checks each one for a confirmed LinkedIn profile — exact matches only, never guessed. Paste a list or upload from CSV.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Max emails per run",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Limit how many emails are processed in one run. Useful for testing or controlling cost.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```