Turn a LinkedIn Profile URL Into an Enriched Lead

Copy this line to your agent to turn a LinkedIn profile URL into an enriched lead.

set up https://monid.ai/SKILL.md and use tikhub /api/v1/linkedin/web/get_user_profile then pdl /v5/person/enrich to turn a linkedin profile url into an enriched lead

Given one LinkedIn profile URL, you can hand back a single lead row a rep can act on today: name, title, seniority, company, location, and a verified work email. It takes two pay-per-call lookups on one wallet, both priced before they run. Monid is a pay-per-call data API marketplace: one key and one wallet reach hundreds of external data endpoints across scraping, people enrichment, social data, and search, with the price shown before anything executes. This is the cookbook. Copy the steps, run them on one URL, and finish with a clean lead you can route.

TL;DR

• Pull the public profile first. TikHub /api/v1/linkedin/web/get_user_profile takes the username from the URL and returns name, headline, location, and work history, no LinkedIn login in the loop. If you would rather scrape and discover the email in one shot, an Apify harvestapi actor does the profile pull too.
• Feed the name and current company into People Data Labs /v5/person/enrich to add the part that makes the row contactable: a verified work email, normalized seniority, and the current employer.
• Keep exactly six fields: full_name, job_title, job_title_levels, job_company_name, location_name, and work_email. That is what a lead needs to route itself.
• Gate on confidence. Set min_likelihood and require an email at run time, so a weak match writes a review flag instead of a wrong somebody.
• One wallet, both providers. The scrape is a fraction of a cent, the enrich a few tens of cents, so a finished lead lands well under a dollar. Live prices are at monid.ai/tools.

What a routable lead actually needs

A profile page is large, but a row a rep can act on is small. Six fields carry it. The name and title tell them who they are talking to, job_title_levels decides whether a human calls or the account nurtures itself, the company matches an account in the CRM, the location sets the timezone you send in, and the verified email is the thing that makes it a lead rather than a bookmark. Everything else on the profile is context you can fetch later if the deal moves.

The recipe below is a two-hop pipeline: the URL gives you a profile, the profile gives you a name and company, and that seed gives you the enriched, contactable record.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More details in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add --label main --key <your-api-key>

More details in the CLI quickstart.

Step 1. Inspect both endpoints (free)

Read the schemas before you spend anything. inspect returns the exact inputs, the price, and the docs, and it never bills. Endpoints start with a leading slash.

monid inspect -p tikhub -e /api/v1/linkedin/web/get_user_profile
# input:   username (from the URL: .../in/janedoe -> "janedoe")
#          include_experiences, include_skills, ... each +1 request
# returns: full_name, first_name, last_name, headline, location,
#          plus work history when include_experiences is on
# price:   PER_CALL, a fraction of a cent

monid inspect -p pdl -e /v5/person/enrich
# input:   name + company | email | profile (LinkedIn URL) | pdl_id
#          knobs: min_likelihood (1-10, default 2), required, titlecase
# returns: full_name, job_title, job_title_levels, job_company_name,
#          location_name, work_email, likelihood
# price:   PER_CALL, tens of cents

The two knobs that keep this honest both live on the PDL call. min_likelihood floors match confidence on a 1 to 10 scale, and its default of 2 is loose. required lets you say a match only counts if it comes back with an email. The field reference is the PDL person enrichment docs.

Step 2. Pull the profile from the URL

The username is the slug after /in/. Peel it off and run the TikHub lookup. This is a GET endpoint, so the query parameters go to --query, and -w waits for the result inline instead of making you poll.

url="https://www.linkedin.com/in/janedoe"
user="${url##*/in/}"; user="${user%%/*}"      # -> janedoe

monid run -p tikhub -e /api/v1/linkedin/web/get_user_profile \
  --query "{\"username\": \"$user\", \"include_experiences\": true}" \
  -w -o profile.json
# -> one profile record, price shown before it executes

Now read the seed out of it. You need two things: who this is, and where they work now.

name=$(jq    -r '(.data // .).full_name' profile.json)
company=$(jq -r '((.data // .).experiences // [])[0].company // ""' profile.json)

If you prefer to scrape and discover the email in the same call, swap this step for an Apify harvestapi LinkedIn actor, which returns the profile and a discovered address per result. The rest of the recipe is identical, since Step 3 still verifies whatever you carry forward.

Step 3. Hand name plus company to PDL person enrich

This is the only expensive hop, and it is where the row becomes contactable. Feed the seed from Step 2 into person enrich, gate the match at 6, and insist on an email so a shell record never bills full freight. The body JSON goes to -i.

monid run -p pdl -e /v5/person/enrich \
  -i "{\"name\": \"$name\", \"company\": \"$company\",
       \"min_likelihood\": 6, \"required\": \"emails\", \"titlecase\": true}" \
  -w -o lead.json

A cleaner shortcut when you trust the URL: pass "profile": "https://www.linkedin.com/in/janedoe" instead of name and company. The LinkedIn URL is the single strongest identifier PDL takes, so it tends to match higher than a name that two people share.

Step 4. Keep the six routable fields

The enriched record is large. Pull the six that carry a lead and drop the rest.

job_title_levels is the field that lets routing run itself. It is an array, so you branch on cxo or director in code without parsing free text.

Step 5. Gate on confidence, write one row

The confidence gate is already half-enforced: because you set min_likelihood and required on the run, a match that cannot clear the bar comes back with no email. So the final gate is simple. If there is a work_email, write the lead. If not, write a review flag and move on.

echo "name,title,seniority,company,location,email" > leads.csv

jq -r 'if (.data.work_email)
        then [ .data.full_name, .data.job_title,
               (.data.job_title_levels // [] | join("|")),
               .data.job_company_name, .data.location_name,
               .data.work_email ] | @csv
        else "review,,,,," end' lead.json >> leads.csv

One URL in, one clean row out. leads.csv imports straight into most CRMs, and mapping job_title_levels to your lead-tier field means the account arrives pre-routed. Because Monid ships as an MCP server, the same two hops run inside an agent handed "enrich this URL and route it," which reads the profile, verifies the email, keeps the confident matches, and queues the rest.

What one lead costs

You see the exact price before every run, always on monid.ai/tools. In magnitude terms:

Inspect both schemas        free
TikHub profile pull         one call, a fraction of a cent
                            (a couple pennies with several include flags)
PDL person enrich           one call, tens of cents
------------------------------------------------------------------
One finished lead:          well under a dollar
No email cleared the gate:  the enrich still bills, the review costs nothing more

The scrape is nearly free, so the real cost is the one verified enrich, and you only pay it on people you chose to research. The lever is Step 3: gate at a likelihood you trust and require an email, and every call you pay for is one meant to become a lead.

FAQ

Do I need TikHub, Apify, and People Data Labs accounts? No. Integrate Monid once and fund one pay-as-you-go wallet. All three providers are reached through the same key, billed at the price shown before each run.

Why two calls instead of feeding the URL straight to PDL? You can pass the LinkedIn URL directly to /v5/person/enrich and skip Step 2. The two-hop version exists because the scrape gives you the live headline, location, and current role to show a rep, while the enrich adds the verified email and normalized seniority underneath. Use one call when all you want is the contactable record, two when you also want the profile.

How do I stop a wrong match reaching my CRM? Raise min_likelihood on the PDL call and set required to emails, as Step 3 does. Anything that cannot clear the bar returns no match, so Step 5 writes a review flag instead of a confident stranger.

What does one lead cost? A fraction of a cent for the profile pull plus a few tens of cents for the verified enrich, so well under a dollar per finished lead. Current per-endpoint prices are at monid.ai/tools.

Run it on one URL

Take a single LinkedIn profile URL you have been meaning to research. Inspect both endpoints for free, run the two hops pay-per-call, and see whether it comes back as a row you can route. If the email clears the gate, point the loop at your list. Start at monid.ai.