Playbooks · Recipe
Pull the people a company actually employs, page until the elements array comes back empty, then run email_finder and email_verifier over the survivors. The employee search bills per result returned, including results you later throw away. The finder and verifier are waterfall endpoints and cost zero on a miss. We do not sequence and we do not send — the last step hands a file to your sequencer.
Last updated September 22, 2026
Pattern: company page → linkedin_company_employees_search (paged) → title filter → email_finder → email_verifier → your sequencer
Credit math: Worked example at stated counts: 40 target companies, 60 employees returned each = 2,400 results at 0.1 = 240 credits, billed on every result including the ones your title filter discards. 520 survive the filter. 520 email_finder calls at 5 credits, 310 hits = 1,550 credits, because the 210 misses return billed:false. 310 email_verifier calls at 2 = 620. 0.1 credits per linkedin_company_employees_search result, 5 credits per email_finder call, 2 credits per email_verifier call
ROI math: The filter runs after you have paid for the rows, so the lever is the query, not the filter. Narrow the search by title or keyword up front and the same 520 contacts cost a fraction of 240 credits in retrieval. Convert credits at your tier rate on /pricing.
Owned internally by: SDR manager or GTM engineer building account-based lists
Best for: Account-based outbound where you already know the accounts and need the humans inside them — 20 to 200 named companies, not an open-ended prospecting sweep
curl -X POST https://api.richapi.ai/api/v1/linkedin_company_employees_search \
-H "x-api-key: $RICHAPI_KEY" \
-H "Content-Type: application/json" \
-d '{"company_url": "https://www.linkedin.com/company/acme/", "page": 1}'
List people at the Acme LinkedIn company page whose titles include
"revenue operations" or "sales operations". Keep pulling pages until a page
comes back with no people in it. For each one, find a work email and verify
it. Give me a CSV of name, title, LinkedIn URL, email, verification status.
Sign up at app.richapi.ai and copy your key.
25 free credits, no card.
Collect the LinkedIn company URLs for your target accounts.
This endpoint works from the company, not from a domain — if you only have domains, resolve them first.
Call linkedin_company_employees_search with page 1 and read the elements array.
Every element is a billable result.
Increment the page and call again.
Stop when elements comes back empty. Do not write a loop that depends on a pagination field — see the warning below.
Filter the collected rows by title in your own code, then send the survivors to email_finder and email_verifier.
Write the verified rows to a CSV and import that into your sequencer.
Sending is your side of the line.
You know the 40 companies. Getting from a company to the four people inside it who own the problem is where the week goes, and it is the part that gets done by hand at 11pm with a browser and a spreadsheet. `linkedin_company_employees_search` takes a company page and returns the people on it, one page at a time. You filter those rows by title yourself, then spend finder credits only on the ones you would actually write to. **[Get 25 free credits — no card](https://app.richapi.ai)**
This endpoint returns an `elements` array. Every element in it is a billable result at a per-result rate, and that is also the only signal you should use to decide whether to ask for another page. The spec also ships a `pagination` object. It arrives with no documented fields, so anything you build on top of it — a total count, a `has_more` flag, a cursor — is a field you invented and nobody promised. Write the loop the boring way: ```python page, people = 1, [] while True: r = post("linkedin_company_employees_search", company_url=url, page=page) batch = r.json().get("elements") or [] if not batch: break people += batch page += 1 ``` A loop that terminates on an empty array costs you exactly one extra call per company and cannot run away. A loop that terminates on a field you guessed can bill you for pages you never asked for.
| Step | Count | Rate | Credits | |---|---|---|---| | `linkedin_company_employees_search` | 40 companies, 2,400 results | 0.1 / result | 240 | | `email_finder` | 520 calls, 310 hits | 5 / call, misses free | 1,550 | | `email_verifier` | 310 calls | 2 / call | 620 | Rates used above: 0.1 credits per `linkedin_company_employees_search` result, 5 credits per `email_finder` call, 2 credits per `email_verifier` call. The retrieval line is the one people misread. You pay for all 2,400 rows, then discard 1,880 of them at the title filter. That is not a bug and it is not a refundable miss. The API returned what you asked for. The fix is to ask for less: narrow the search query before you page it, rather than pulling the whole org chart and sorting it out afterwards. Convert to currency at your tier rate on [the pricing page](/pricing).
This recipe ends at a CSV. RichAPI has no sending infrastructure, no warmup, no inbox rotation, no unsubscribe handling, and no plans to pretend otherwise. We are the data layer. Smartlead, Instantly, Apollo, HubSpot sequences, your own SMTP: whatever you already run stays where it is. That also means deliverability is yours. We can tell you an address resolves; we cannot tell you your domain is trusted.
**The company page is not the org chart.** You get people whose LinkedIn profile associates them with that company. Leavers linger, contractors appear, and someone who updated their title in 2021 is listed under it today. Verify seniority against something else before you write "as VP of RevOps at Acme." **Big companies are expensive to enumerate.** Forty mid-market accounts is a sensible batch. Forty enterprises with 20,000 employees each is a per-result bill you did not mean to sign. Filter in the query, cap your page count, and know your ceiling before the loop starts. **A found email is not a verified email.** `email_finder` returning an address means a provider produced one. `email_verifier` is a separate call and a separate decision, and skipping it is how a list burns a sending domain. See [verify before the sequence push](/use-cases/verify-before-sequence-push). **Personal inboxes are a different endpoint.** If the work address comes back catch-all and your risk tolerance is low, `find_personal_email` exists, bills on any 2xx including an empty one, and carries its own consent questions. [Catch-all then personal email](/use-cases/catch-all-then-personal-email) covers that branch.
If you do not have the account list yet, [signal-based prospecting](/use-cases/signal-based-prospecting) and the rest of [the use-case index](/use-cases) build one from activity rather than from a static target set. For the general list-then-verify shape, see [list build and verify](/use-cases/list-build-and-verify). The endpoint reference is [the email finder API](/api/email-finder), and [Claude via MCP](/integrations/claude) runs the whole chain conversationally for one company when you are spot-checking rather than batching.
**How do I know when to stop paging?** An empty `elements` array. Not a count, not a flag, not a page total. That is the whole rule. **Do I pay for employees I filter out?** Yes. Billing happens when the result is returned, not when you decide you want it. Narrow the query instead of widening the filter. **Can I search by title inside the endpoint rather than filtering after?** Check the request schema in the live OpenAPI before you assume a parameter exists. **Does this send the emails?** No. We have no sending or sequencing product. You get rows; your sequencer gets the rows. **What happens if a company page has no employees indexed?** You get an empty `elements` array on page 1, you stop, and you paid for zero results. Per-result billing at least makes that case cheap. **Do I need a credit card?** No. 25 free credits on signup.
Run it against one company you know well and check the list against what you already know is true. **[Get 25 free credits](https://app.richapi.ai)**