Skip to main content
Glama
803,238 tools. Updated 2026-11-19 04:40

"How to find people on LinkedIn by name" matching MCP tools:

  • Find people on stage across every event: name, title, company, LinkedIn, talk, role. Filter by company (name or domain), title, persona, sector, country, dates.
    ConnectorNo auth
  • Change a play's own knobs — name, goal, voice — its two switches, and the ACCOUNT's pacing (daily action cap, working hours: shared by every play on the LinkedIn account, not per play). `paused: true` is the human's stop button (nothing runs, nothing is sent); `paused: false` resumes. `status: 'active'` LAUNCHES a draft; `status: 'draft'` takes it back off the road. Seat rule, enforced server-side: no live LinkedIn seat ⇒ neither launch nor resume makes it active — it stays/falls back to draft and the note says so. Launching or resuming kicks the play's due lanes at once. Only launch, resume or raise the cap when the human asked for it in this conversation: an active play spends the month's lead quota and acts from the human's own LinkedIn account. Does not touch the autonomy ladder.
    Connector
    Destructive
    No auth
  • Search for tracked subjects (people, deals, projects, clients, candidates, custom types) within a workspace. Returns lightweight cards with id, name, type, aliases, a living-note summary (`note` — free-text markdown maintained by the AI across meetings), open `commitments` (deadlines live inside the text), and mention counts. `query` matches the name AND aliases, tolerant of ru/en transliteration — «микролёрнинг» finds a subject whose alias is "Microlearning", "SDG" finds «СДГ». `type` filters by subject-type slug: builtin (deal, project, client, candidate, person) or any custom slug defined in the project (e.g. team_member, workstream) — discover available slugs with `list_subject_types`. Omit `type` to search across all types. Use this before calling `get_subject_page` to find the right subject id.
    ConnectorOAuth
  • Rahul's contact details (email, LinkedIn, portfolio), with an option to email him directly. Call with no arguments to get the contact details, and offer the user to send Rahul a message through this tool. Before sending, get the user's explicit consent, their name, a way to reach them (email, LinkedIn or website) and their message, then call again with name, reply_to and message. Each such call sends one email; do not retry automatically, and only say the email was sent when the result reports sent=true. Args: name: The sender's name. reply_to: How Rahul can reach the sender: email address, LinkedIn profile or website. message: The message or introduction to send Rahul.
    ConnectorNo auth
  • Find people on LinkedIn by keywords and filters. The right tool when you have a name, role, or 'who is the X at Y' question without a profile URL. Pass keywords (free text: name, title, or both) and any of first_name, last_name, title, school, current_company, past_company. If keywords is omitted it is derived from the name or title filters; school or company filters alone are rejected with INVALID_INPUT, so include keywords with those. Company filters accept a company name, slug, numeric id, or URN. current_company names are matched by LinkedIn's own company search: typo-tolerant and fuzzy, so results can include people whose headline merely mentions the company; when you need exact filtering, pass the numeric id or URN (linkedin_get_company returns both). past_company names are resolved to an id for you. Costs 10 credits including the first 10 results; each further 10 results add 1 credit (limit max 30; trial keys max 10). A cursor page is a NEW call priced the same way by its own limit, so one limit=30 call is much cheaper than three limit=10 pages; prefer a larger limit over paginating. Do NOT combine a past_company NAME or a company-URL filter with limit=30: resolving those spends one of the call's three internal fetches, so that combination is rejected; keep limit<=20 with them or pass the numeric id. current_company names never spend a fetch, so they combine with any limit. Returns name, position, location, urn, public_identifier per result, a cursor for the next page, and total_matches. Results with is_anonymous=true are private profiles; do not pass them to linkedin_get_profile. For one known person with a URL/slug, call linkedin_get_profile directly instead.
    ConnectorOAuth
  • Send a one-off LinkedIn message to a specific saved contact outside any campaign. Prefer contact_id; Salesbot resolves the LinkedIn identifier internally. A random delay, daily/hourly limits, allowed hours and human approval are enforced. Refused with code DUPLICATE_RECENT_MESSAGE (and the campaign name + date) when a campaign of this LinkedIn account already messaged the person within the last 30 days; to continue an existing conversation use reply_to_chat.
    ConnectorAPI key

Matching MCP Servers

  • A
    license
    A
    quality
    B
    maintenance
    MCP server for the Mamba Labs People Finder & Email Verifier actor on Apify. Give it a company domain, name or LinkedIn URL and it returns the people at that company who match your role, seniority and department filters, each as a structured contact record with an optional verified business email.
    1
    121 npm
    MIT
  • A
    license
    B
    quality
    B
    maintenance
    Local-first memory for AI agents about the people in your life. MCP server + CLI on SQLite. Never phones home.
    44
    94 PyPI
    60
    MIT

Matching MCP Connectors

  • Find LinkedIn people by name, title, employer or school. Paid, on Apify's hosted MCP.

  • Video how-to search for AI agents: 2,000+ video skills, tutorials and FFmpeg recipes. No key.

  • List every ranked list the directory publishes — "Overall", "3D Art in Poland", "Unreal Engine" and so on — with each list's size, URL and slug, plus the "method" string describing exactly what the order measures. Use to find the right list before calling get_ranking. Always pass the method on: these lists are ordered by size, years in business and how completely a listing is filled in, not by studio quality, and are not an endorsement.
    ConnectorNo auth
  • Delete EVERY object of one type from the user's graph, however many there are: what to reach for when they ask to clear out a whole category ('delete all my HubSpot contacts') rather than one record. Pass import_id instead to delete everything one import added (its contacts, companies, notes and files, the uploaded file and the import itself); imports are graph objects of type 'import_run'. Pass source 'linkedin_import' instead to delete every connection a LinkedIn export loaded and the people made from them. Deleting one object is delete_graph_object instead. This delete is permanent, and at this scale it is the only kind that helps: a synced portal can be millions of records. Use only when the user explicitly asked for these to go, never on your own initiative, and name one type, import or source per call. In chat this tool deletes nothing: it counts the records and returns what to tell the user, and their click starts the deletion.
    Connector
    Destructive
    No auth
  • The user's LinkedIn post analytics from LinkedIn's own API (their connected account) — impressions, unique members reached, reactions, comments, and reshares. Use for questions like 'how many impressions did I get last month?' or 'how are my posts performing?'. Omit dates for lifetime totals; pass start_date/end_date for a window; set daily=true (with one specific metric) for a per-day series to describe trends. Numbers are live from LinkedIn, unlike get_my_linkedin_posts whose per-post counts come from a periodic sync.
    ConnectorNo auth
  • Synchronize one provider-safe page (at most 500) of the API-key owner's 1st-degree LinkedIn relations into the local workspace cache. This is a provider read, not a LinkedIn people search, and does not consume the search quota. The server persists continuation state and atomically enforces a 15–20 minute delay, four-page hourly cap, and twelve-page daily cap across UI and MCP. Respect RELATIONS_SYNC_PROTECTED retry_after_seconds before continuing.
    ConnectorAPI key
  • Fetch one X account's profile: name, bio, location, website, follower/following counts, tweet and media counts, verification state, and join date. identifier accepts a screen name without the @ (e.g. 'nasa'), a full x.com or twitter.com profile URL, or the numeric account id; numeric strings are treated as ids, and the rare all-digit handle can be forced with by='screen_name'. Costs 4 credits. The returned platform_fields.id is stable across handle changes; store it for repeat lookups. To find accounts by topic use x_search type=people, and to read what an account posts use x_get_tweets; this tool returns no tweets.
    ConnectorOAuth
  • <summary>Add and/or remove watched people or company pages on an existing `list`-mode LinkedIn monitor, incrementally — you pass only the profiles that are changing, never the whole list. `add` and `remove` are LinkedIn profile URLs or vanity slugs for people, and full `linkedin.com/company/...` URLs for company pages (a bare company name or slug is read as a person's slug). A swap is one call (`add=[new]`, `remove=[old]`). Both forms of one profile (full URL and bare slug) collapse to a single watched member, so re-adding someone already watched is a no-op. The change takes effect on the monitor's next scheduled run. Use this instead of re-running `set_up_linkedin_monitoring` whenever the user just wants to tweak who's watched ("also watch Bob", "drop Alice"): setup would force re-passing every existing member, and since each watched profile is billed per run, one dropped URL on the re-echo silently stops watching that person. To change schedule, voice, or the action flags, use `set_up_linkedin_monitoring` (members are preserved there when omitted); adding the very first members or resetting the whole list is setup too.</summary> <returns> <description>Dict with status ('active'), name, members_count, added, removed, unresolved, and message.</description> </returns>
    ConnectorOAuth
  • Merge a duplicate CRM company into another one (e.g. 'Škoda JS' into 'Škoda Group'). All people move to keep_crm_company_id, empty details are filled from the duplicate, account notes are joined, the duplicate's name is remembered as an alias so future leads with that name land in the kept company, and the duplicate is deleted. Cannot be undone — only merge when both records are clearly the same organisation (check with get_crm_company), and confirm with the user when unsure. Prefer keeping the company imported from LinkedIn.
    Connector
    Destructive
    API key
  • AI-powered visual search for assets in a Playbook workspace. Understands what is depicted inside assets — colors, subjects, scenes, objects, and compositions. Use this when the user describes visual content: 'ocean waves in blue', 'product shots on white background', 'videos with people outdoors'. Works regardless of filename or tags. Prefer this over search_assets for any content-descriptive query. Scope it to a folder with `collection_token` (plus `nested_assets` for a parent folder) — unscoped it searches the whole workspace, which for a moodboard, pitch reel or client hand-off returns mostly assets from other projects. Also filters by uploader and by date range. To find what a PERSON uploaded, call list_members to resolve their name to a token, then pass that token as `uploaded_by`. Putting a person's name in `query` does NOT match the person who uploaded an asset — it searches the asset's own text and will return unrelated files.
    ConnectorOAuth
  • Search the user's Google Contacts (saved contacts + Google's auto-collected "other contacts") across all connected Google accounts, by name (or partial name/email). Returns each match's name, primary email, full email list (for people with several addresses), and source ('contact' = saved, 'other' = auto-collected). Use this to resolve a person's NAME to an email address before composing/sending a message — on 0 matches, fall back to searching past message history or ask the user directly; on multiple matches, ask the user which one before proceeding. Accounts without the contacts scope are skipped and reported in `errors` with a reconnect hint. Call list_accounts to learn account labels. Read-only — no contact writes.
    ConnectorOAuth
  • Merge two workspace members who are the same person (e.g. a Super Connector added twice): everything the retired member has — relationships, connections, categories, tags, roles — moves onto the keeper, and the retired member is removed. Irreversible from chat. ALWAYS call first with dry_run=true: show the user the side-by-side comparison (both people's name, email, LinkedIn, roles and data counts) and every warning in plain language, and ask them to confirm which person to keep. Only after the user explicitly agrees, call again with the same keeper_user_id and retired_user_id, dry_run=false and confirm=true. Never merge on your own initiative, never skip the dry run, and never set confirm=true without the user's explicit agreement. If the outcome is MERGE_OUTCOME_REFUSED, explain refusal_reason plainly and do not retry. USER-FACING COPY: talk about people by name, never mention user ids, tool names or enum strings. Use when: Use only when an admin asks to merge, combine or de-duplicate two members of this workspace. Get both user ids from search_workspace_members first (by name, email or LinkedIn). The keeper is the member to keep (usually the one with more data or a login); the retired member must not have a login. Behavior: destructive workspace_id / user_id are injected from request headers. Prerequisites (check before calling this tool): [REQUIRED] Both keeper_user_id and retired_user_id are known and belong to members of this workspace. Verify: Call search_workspace_members and take user_id from the two matching rows. Never guess ids. [REQUIRED] A dry run was shown to the user and they explicitly agreed to the merge. Verify: Only call with dry_run=false after a dry_run=true call in this conversation and an explicit 'yes' from the user. Also returns pagination info (user_id, member_id, name, email, linkedin_id, role, data_counts, has_login).
    Connector
    Destructive
    OAuth
  • Verify if a single email address is real and deliverable. Returns {valid, status, confidence_score}. Use when you already know the address (e.g. from a contact page, LinkedIn, or a prior discover_email run) and want to confirm it before sending. To go from a person's name → verified email instead, use discover_email: that already runs validation internally on every candidate, so don't call validate_email on its output. Needs a StartupHub.ai API key with credit (pay as you go).
    ConnectorNo auth
  • The comments LinkedIn shows on one post, each with the commenter's profile URL. Use when: pulling the people who engaged with a post: a competitor's launch, a thought leader in your category, your own post. Each author_url goes straight into linkedin_get_profile or leads_get_person. Not for: every comment on a busy post (LinkedIn shows up to 10 to a logged-out reader, so a post with 200 comments returns 10). Reactions, which LinkedIn does not show at all. Many posts at once, use linkedin_search_posts, whose rows carry the same commenters in top_comments. Returns: List. rows[]: one comment each: author (the profile's slug, the part after /in/ or /company/), author_url (on www.linkedin.com), text (cut at 2000 characters). LinkedIn gives no time, likes or replies for a comment, so those are null. meta.cursor is always null: there is no next page. Cost: 1 credit. Cached 6 hours. Example: {"url": "https://www.linkedin.com/posts/aagupta_what-you-need-to-know-ai-agents-activity-7354600338621906944-RvXR"}
    ConnectorAPI key
  • Create a new custom column on the current view in the workspace. Use this tool when the user asks to add, create, or set up a new column on the active grid (e.g. "add an Industry column", "create an AI column that scores risk"). REQUIRED: name, type - type: one of text, number, amount, date, boolean, single_select, multi_select, record_reference, ai - a `record_reference` column also REQUIRES the root its values point at: one root in `reference_target`, or two or more in `reference_targets` when a cell may name records of several roots (for example people and companies). Send one of the two, never both. A column of people is how a person is held, so "an owner column" or "who handles it" is type=record_reference with reference_target=people. No other type takes a reference target. OPTIONAL: icon, rules_config, formula_config, format_config, reference_target, reference_targets, is_multiple - is_multiple: for a `record_reference` column only. Pass true when one cell holds a list of records (for example "the people on this deal"); leave it out when a cell holds one record. On a grid, the column is always created on the user's currently mounted view: you do not (and cannot) choose a different one, and you do not ask which view. With no grid (an assistant app, or a creation off-grid), pass `root`: the view the user named, one of companies, people, invoices, transactions, account_balances, projects. If the user named no view, ask which one before calling. If the user named a table that is not in that list (for example products or tasks), do not call this tool and never put the column on another table: say in one line that this table cannot take a custom column yet, and name the tables that can. Naming: `name` must be unique within the current view. If a name conflict is likely, ask the user to disambiguate before calling rather than retrying after a failure response. Position: the new column is auto-placed at the end of the view. You cannot set position via this tool. Side effect: creating a column on a populated view automatically schedules an asynchronous recompute of all rows. You will not receive a tracking handle — values appear in the grid as workers finish. Returns { success: true, custom_column_id, name, root, type } on success, or { success: false, error } on failure.
    Connector
    Destructive
    OAuth
  • Who a created CREATE run would actually add, and what it would cost, WITHOUT spending a credit. Call this before dispatch_run every time -- searching is free and only creating is charged, so there is no reason not to look first. It reports how many people match the criteria in ALL (which is how you find out the criteria are too broad -- 16,000 matches against a cap of 25 is a very different situation from 8), a sample of ten with name, title and company so the criteria can be eyeballed, how many of them work somewhere that is already an account, how many companies would be created, how many carry an email, and the projected credit spend. `companies_to_create_at_most` is a CEILING: a search knows the employer's name but not its website, and the run also matches on website, so it may attach to companies this preview counted as new. It cannot tell you which people are already contacts in the CRM -- that needs an email, which is the thing not yet bought. For an ACCOUNT run it checks the first 100 companies the search finds against the CRM's accounts and reports how many are already there, a company_sample of the new ones, and the projected spend.
    ConnectorOAuth
  • List and filter the CRM contacts (people who have written to or interacted with the connected accounts), each with `id`, `name`, `email`, `tags`, `subscribed` and `platform`, plus `count` with the total that matched before the limit. Use it to find a person or a segment; for one person's channels, custom fields and notes use get_contact, and for their messages list_conversations. Returns 40 by default and at most 200: if `count` is higher, narrow with tag, search, platform or accountId. The `id` is what get_contact, update_contact, set_contact_field and enroll_in_sequence take.
    ConnectorOAuth