Get the contact details and profiles for RZ AI Labs / Amit Raz (email, phone, LinkedIn, X, location).
ConnectorNo auth
584,866 tools. Updated 2026-09-17 22:16
"A service for finding LinkedIn user profiles by name and location" matching MCP tools:
- Enrich existing contacts with their full LinkedIn profile data via the connected LinkedIn account (Unipile) — headline, location, current company & position, full experience, education and skills are scraped from each contact's profile URL and saved onto the contact (and merged into profile_data). Use after search_google_xray to flesh out lightly-saved leads. Each contact is a real LinkedIn profile view, so keep batches small; max 8 per call. Returns per-contact enrichment status.ConnectorNo auth
- Use when the user wants to find public developers by skill, name, language, location, agent availability, or active opportunity intent. Start discovery here; no authentication is required. Example: {"query":"TypeScript maintainers","location":"Germany","availableForAgents":true,"limit":5}.ConnectorNo auth
- Returns the plain-language meaning and step-by-step fix for one Malinois finding. Use it while helping the user fix an issue reported by scan_app, or when they ask what a finding means. Pass the rule_id exactly as scan_app returned it. Read-only, no network, instant.ConnectorNo auth
- Batch-fetch up to 100 profiles by (platform, username) pairs. Use this when the user has a list of handles and you need profile data for all of them at once (e.g., "give me follower counts for these 30 accounts I'm considering" or "which of @a @b @c are real accounts?"). One round-trip beats 30 calls to `get_profile`. Use this for exact batch handle lookup, not semantic discovery. For one exact platform+username pair, use `get_profile`. For partial or fuzzy handle/name input, use `search_creators` or `autocomplete_creators`. Use `semantic_search_creators` only for topical/niche/audience discovery where false-positive semantic matches are acceptable. Examples: - User: "Compare @a, @b, and @c on Instagram" -> use this tool for the exact handle batch. - User: "Give me follower counts for these 30 accounts" -> use this tool. - User: "Find wellness creators in Austin" -> use `semantic_search_creators`, not this tool. The response splits results into `data` (profiles found) and `not_found` (the (platform, username) pairs that weren't recognized). Profiles are returned in no particular order — re-correlate via the platform/username fields if you need to preserve input order.ConnectorNo auth
- Batch-fetch up to 100 profiles by (platform, username) pairs. Use this when the user has a list of handles and you need profile data for all of them at once (e.g., "give me follower counts for these 30 accounts I'm considering" or "which of @a @b @c are real accounts?"). One round-trip beats 30 calls to `get_profile`. Use this for exact batch handle lookup, not semantic discovery. For one exact platform+username pair, use `get_profile`. For partial or fuzzy handle/name input, use `search_creators` or `autocomplete_creators`. Use `semantic_search_creators` only for topical/niche/audience discovery where false-positive semantic matches are acceptable. Examples: - User: "Compare @a, @b, and @c on Instagram" -> use this tool for the exact handle batch. - User: "Give me follower counts for these 30 accounts" -> use this tool. - User: "Find wellness creators in Austin" -> use `semantic_search_creators`, not this tool. The response splits results into `data` (profiles found) and `not_found` (the (platform, username) pairs that weren't recognized). Profiles are returned in no particular order — re-correlate via the platform/username fields if you need to preserve input order.ConnectorNo auth
Matching MCP Servers
- AlicenseDqualityDmaintenanceProvides access to the Timezone By Location API to retrieve timezone information based on geographic location data.1MIT
- AlicenseAqualityAmaintenanceProvides agents with real Linux VMs to run commands, manage files, expose ports, and track costs, all through an ephemeral sandbox service.11MIT
Matching MCP Connectors
City geocoding and timezone resolution for birth data, for AI agents, one API key.
LinkedIn: The LinkedIn Data API offers access to detailed information on individuals, companies.
- Generate synthetic / fake user profiles via the MwVideos random_users API (POST /mwvideos/api/random_users). Returns name, gender, location, email, login, dob, phone, picture, and nat. Use when the user asks for random users, fake people, sample contacts, demo personas, UI fixtures, or test profiles. Pass `results` for how many profiles (default 1, minimum 1) and `isPro` as 0 or 1 when relevant (default 0). Authenticated user_id is injected server-side — do not invent profiles; always call this tool. These are FAKE people for demos and testing, not real PII.ConnectorOAuth
- Ask CampaignStack to send one connection request from a LinkedIn account the workspace owner connected. Call this when the user has named one specific person and confirmed sending the request. platform is required ("linkedin"; connection requests are a LinkedIn-only concept, and on other networks you follow instead with campaignstack_follow_profile). Name the person with leadId, which is the supported form; profileUrl is accepted for someone already in the workspace. An optional note is capped at 300 characters by LinkedIn. The workspace's only connected LinkedIn account is used automatically, or pass accountId (campaignstack_list_accounts). This reaches a real person. Before calling it, tell the user exactly who it goes to and read the wording back to them, and wait for an explicit yes. It goes out as soon as this call succeeds: there is no draft state and nothing to recall. One person per call. There is no bulk form, and calling this in a loop over a list is not the supported way to reach a list: put the leads in a lead list with campaignstack_add_leads_to_list and run a workflow over it with campaignstack_trigger_workflow, which paces the sends and applies the review step the workspace configured. Sending is paced by CampaignStack's own daily and weekly limits and business hours, which are set by a human in the app and are not writable from here; see overrideOwnLimits before asking for an exception.ConnectorDestructiveAPI key
- The list-building tool. Re-runs a plain-English people search and unlocks up to `count` full profiles in ONE atomic charge: 1 credit per newly unlocked person, and anyone you already own is free. Returns each person's real name, title, company, location, LinkedIn URL and an `id`. Emails are NOT fetched here (that is a separate credit): after unlocking, call fetch_email with each person's `id` to get their verified work email. WARNING for autonomous use: this can spend up to `count` credits in a single call, so choose `count` deliberately and confirm with the user before large batches. Returns an out-of-credits error instead of overspending.ConnectorNo auth
- <summary>Search LinkedIn for people — by name, by a specific person's connections, or by profile filters — and return the matching profiles. Provide `keywords` (a name or search term) or a scope filter (`connections_of` / `advanced_keywords`). One call runs one query, returning ~10 matches by default (one page). To go deeper on a single query — "find people in my network matching my ICP" — pass `max_results` (up to 100): the tool pages through the matches for you, each ~10-profile page counting as one search against the daily budget. To search *different* people — a list of names, or one filter per company — loop this tool inside a `run_code` block, one call per name or company (that's breadth; `max_results` is depth on one query). Searches are paced a few seconds apart and serialized across this user's LinkedIn work, so a deep search or a long loop can take a couple of minutes; tell the user to expect a short wait before a large run. If a search comes back paused or rate-limited, stop and tell the user which searches remain — the account is paused and further calls won't run until it lifts. Scope filters combine with `keywords` and can be used alone for a single filtered search: - `connections_of` — restrict to the first-degree connections of specific people, passed as their `provider_id`s (as returned by an earlier search or profile lookup). To work up to a buyer through someone the user just connected with, pass that person in `connections_of` and the target company in `advanced_keywords={'company': 'Acme Corp'}` to surface who they know there. `network_distance` is a separate filter on the user's *own* degree and combines with this — add [2] to keep just the connections the user isn't already directly linked to. - `advanced_keywords` — native LinkedIn keyword sub-filters: a dict with any of `first_name`, `last_name`, `title`, `company`, `school` (each a string). - `profile_language` — ISO 639-1 codes (e.g. ['en']) that narrow any of the above to profiles written in those languages. A refinement, not a search on its own — pair it with keywords or another filter. When the results are a set the user will act on — a discovery search, the people connected to someone, prospects to work through — pass `list_name` (a short slug) to save them to the workspace Output tab as that named list. Reuse the same slug across a loop or follow-up searches to gather everything into one list (saves are deduped by profile). Omit it only for a throwaway lookup, like resolving one prospect's profile from a name. Saving needs an active task. Returns up to `max_results` matching profiles with provider_id, name, headline, network_distance, location, and profile_url — each match's `headline` shows their current role and company (e.g. to see which companies 2nd-degree matches work at). `total_count` is LinkedIn's full match count for the query when it returns one, but LinkedIn now omits it on most Classic searches (so it's often null): only say "showing N of ~M" when it's a number exceeding the profiles returned, and never invent a total. Use `has_more` — True when more results exist beyond those returned — to decide whether to offer to pull more. Present the results to the user so they can pick the right person. An `error` about being "heavily queued" is transient pacing back-pressure — retry shortly rather than reporting it as not found. That field list is the whole of it — a search result carries no connection count, follower count, or employment history. Present what comes back as it is; a search the user wanted to look at is finished at that point. When the ask genuinely needs one of the missing fields — a connection-count threshold, employment history to personalize from — pass the matches' profile URLs to `enrich_linkedin_profiles`, which returns them for the whole list in one paid call (`connections_count` is the field a connection-count filter reads) and spends no LinkedIn account budget. When the decision also turns on whether the user is already connected to them, use `setup_linkedin_sequence(action_type='resolve')` instead; connection status is the one thing enrichment cannot answer. Rate-limited — shares one daily LinkedIn search budget with all other LinkedIn people searches.</summary> <returns> <description>On success, a dict `{'success': True, 'profiles': [...], 'total_count': int | None, 'has_more': bool, 'searches_remaining_today': int}`. `profiles` holds up to `max_results` matches; `total_count` is the query's full match count when LinkedIn returns one (often null since its Aug-2026 Classic Search change), so lean on `has_more` for whether more results exist; and `searches_remaining_today` is the post-search budget, so you can size a follow-up loop without re-checking. When `list_name` is set, also `saved_to_list` and `saved_count`; if no task was active, `saved_to_list` is null with a `persist_note`. If the account tripped its pause partway through paging, the (still valid) partial results come back with `paused: True` and a `note` — surface it: further searches won't run until the pause lifts. On a failed search: `{'success': False, 'profiles': [], 'error': ..., 'searches_remaining_today': int}`. On a pre-flight refusal (daily limit reached or account paused), `searches_remaining_today` is omitted: `{'success': False, 'error': ...}`.</description> </returns>ConnectorOAuth
- Search 500+ quantum computing job listings using natural language. Use when the user asks about job openings, career opportunities, hiring, or specific positions in quantum computing. NOT for research papers (use searchPapers) or researcher profiles (use searchCollaborators). Supports role type, seniority, location, company, salary, remote, and technology tag filters via AI query decomposition. Limitations: quantum computing jobs only, last 90 days, max 20 results. Promoted listings appear first (marked). After finding jobs, suggest getJobDetails for full info. Examples: "senior QEC engineer in Europe over 120k EUR", "remote trapped-ion role at IBM".ConnectorNo auth
- Get one or more Twitter user profiles by IDs or usernames (1-100 per request). Use identifierType="id" for numeric user IDs, identifierType="username" for usernames. All identifiers must be the same type. For single user: pass array of 1, e.g. identifiers=["elonmusk"]. For person names or fuzzy search, use searchTwitterUsers instead. PERFORMANCE: More efficient than multiple single calls, but can still take time for many users. Returns only found users, omitting not-found identifiers for flexibility. Optional fields parameter for performance (default: ["id", "username", "name"]). Available fields: id, profileImageUrl, profileBannerUrl, profileInterstitialType, status, username, verifiedType, name, description, location, protected, verified, followersCount, followingCount, tweetCount, listedCount, likesCount, mediaCount, pinnedTweetId, source, nLang, nLangsFiltered, label, labelType, isVerified, modifiedAt, createdAt, verifiedSinceDatetime, accountBasedIn, locationAccurate, usernameChanges, lastUsernameChangeDatetime. NOTE: Use "tweetCount" not "statusesCount". Returns: array of user profiles with count and dataSource. This is a safe, read-only tool for analyzing searchable information.ConnectorOAuth
- Find vetted, licensed locksmiths near a location. Use this first when a user needs a locksmith. Returns a ranked list of human-vetted providers (featured first) with id, name, city, services, rating, verified/featured flags, phone, and a profile URL. Args: location: A 5-digit US ZIP code (preferred) or a US city name. service: Optional job type, e.g. "lockout", "automotive", "residential", "commercial", "rekey", "install", "safe". urgency: Optional, e.g. "emergency", "today", "scheduled". budget: Optional free-text budget hint. limit: Max results to return (1-20, default 5). Note: price and ETA are NOT pre-listed — they are confirmed by the locksmith after you call request_quote. Do not invent prices or ETAs.ConnectorNo auth
- Creates a Zeekeo LinkedIn campaign: sends a connection invite using invite_template_id, and optionally — if followup_template_id is given — waits for the invite to be accepted, then sends a follow-up message using that template. Create templates first with zeekeo_create_template. Provide exactly one of filter_url (a LinkedIn search results URL) or profile_urls (specific profiles) as the target. This starts REAL LinkedIn automation once the campaign has profiles in it — confirm with the user before calling. Requires the user to have connected their own Zeekeo Launchpad account. Direct them to rankparse.com/dashboard/integrations to connect it.ConnectorNo auth
- Map LinkedIn Ad Library links (linkedin.com/ad-library/detail/<id>), sponsoredCreative URNs or bare LinkedIn creative ids to the ads in this account's Metadata library, so an ad the user points at by its LinkedIn link can be REUSED in a new campaign instead of rebuilt. WHAT IT CAN AND CANNOT RESOLVE (repeat this to the user when a link is not found): - It resolves ONLY ads that were launched THROUGH METADATA. Every ad Metadata publishes to LinkedIn is recorded with the LinkedIn creative id LinkedIn gave it, and that id is exactly what the Ad Library link carries. Those come back with the library ad (id, name, type) plus the experiment and campaign that ran them, ready to attach by name. - An ad launched natively in LinkedIn Campaign Manager (a sponsored personal post, a Thought Leader ad, anything built outside Metadata) is NOT in the library and CANNOT be imported from the link, by this tool or any other. The only way to run it here is to rebuild it from its source files (image, video, PDF) with the ad tools. - LinkedIn only. Meta or Google ad library links are refused per item. HOW IT SEARCHES: the platform has no lookup by LinkedIn creative id, so this scans the account's LinkedIn ads newest first (100 per page, `max_pages` pages, default 20, so the newest 2,000 ads) and stops as soon as every id is found. A miss with `reached_end: false` means the ad may simply be older than the scan: pass `campaign_ids` to narrow the scan to the campaigns that ran it, or raise `max_pages`. A miss with `reached_end: true` means the account never launched that ad through Metadata. PARAMETERS: - links: Ad Library URLs, `urn:li:sponsoredCreative:<id>` URNs or numeric LinkedIn creative ids (1 to 20 per call). - campaign_ids: optional wizard campaign ids that restrict the scan. - max_pages: optional, 1 to 50, default 20. RETURNS: {success, found, not_found, scanned_ads, scanned_pages, reached_end, results: [{input, linkedin_creative_id, found: true, library_ad: {id, name, type, channel, status, image_url}, experiment: {id, name, goal}, campaign: {id, name, status}, stats: {spend, impressions, clicks, leads}, destination_url, reuse} | {input, linkedin_creative_id, found: false, reason}]} NEXT STEPS: attach a found ad by its library NAME through create_campaign / add_and_edit_campaign_elements (`ads.list`), or read it with get_ad_details(ids=<library_ad.id>). Never re-upload a found ad's creative: that creates a duplicate library entry.ConnectorAPI key
- List the LinkedIn conversion actions (Insight Tag conversions) available on the connected LinkedIn ad account, with id, name, type and whether each is enabled. Use it to pick the ids for update_linkedin_channel_settings.conversion_action_ids (which conversions a campaign optimizes toward and reports on), and to answer "which LinkedIn conversions do we track?" or "is the /pricing page conversion set up?". KEYWORDS: linkedin, conversions, conversion actions, conversion tracking, insight tag, website visit conversion, lead gen form conversion, url conversion, page visit, pixel Requires a connected LinkedIn channel (check get_integrations_status). Conversion actions are created in LinkedIn Campaign Manager, not here: when the one the user needs (for example a URL rule for /pricing) is missing, say so and point them at Campaign Manager instead of inventing an id. RESPONSE: {success, count, conversions:[{id, name, type, enabled, last_received_at}]} `enabled: false` conversions cannot be attached to a campaign (launch validation rejects them). `last_received_at` is when LinkedIn last recorded a hit; null means the conversion has never fired.ConnectorAPI key
- Create a **G2 Intent - LinkedIn Native (Dynamic)** audience (platform `customAudienceType=DYNAMIC_G2`). AUDIENCE TYPE (mirrors the UI's "Audience Type" dropdown): • UI label: "G2 Intent - LinkedIn Native (Dynamic)" • Platform enum: DYNAMIC_G2 • Refreshes daily as G2 intent signals update; targets LinkedIn natively. PREREQUISITE: • Both G2 and LinkedIn integrations MUST be connected. If either is missing, do NOT call this tool — recommend `create_firmographic_audience` instead. WHEN TO USE (exact user phrasing this tool should match): • "G2 Intent - LinkedIn Native (Dynamic)" • "G2 LinkedIn Native Dynamic" • "LinkedIn native G2 intent audience" • The user explicitly mentions BOTH G2 intent AND LinkedIn native targeting. WHEN NOT TO USE: • If the user asked for "G2 Intent (Dynamic)" without "LinkedIn Native" → use `create_g2_intent_dynamic_audience`. • If the user asked for "G2 Intent (Static)" → use `create_g2_intent_static_audience`. BUYING STAGES — REQUIRED BY THE PLATFORM: The platform UI marks Buying Stages as required. If the user did not name any stages, STOP and ask the user which of AWARENESS / CONSIDERATION / DECISION to target. DO NOT silently default — that produced wrong audiences in PRD-29702 / PRD-29703. CRITERIA (LinkedIn-native shapes; free-text fields are resolved server-side via the LinkedIn references API): • employees — LinkedIn-native employee ranges. Valid labels: see the schema (e.g. "201-500", "501-1000", "1001-5000"). • revenues — LinkedIn-native revenue ranges (e.g. "$1M-$10M", "$10M-$100M"). • company_names — free-text company names (resolved to LinkedIn company IDs). • location_country_ids — country IDs (e.g. 229=US, 228=UK). • job_titles — free-text titles (resolved to LinkedIn job-title IDs). • skills — free-text professional skills (resolved to LinkedIn skill IDs). PARAMETERS: • name (required, ≤ 50 chars) • intent_days (required, 1-365) • buying_stages (REQUIRED by platform — ask the user if missing; do NOT default) • employees, revenues, company_names, location_country_ids, job_titles, skills (all optional) RETURNS: id, audience_id, audience_name, audience_type (DYNAMIC_G2), status, buying_stages, intent_days, expectedNumberOfCompanies, expectedNumberOfContacts.ConnectorAPI key
- Use this tool when the user wants to see service packages with fixed pricing and scope for a specific type of service. This tool returns standardized packages offered by service providers, including pricing tiers, deliverables, and delivery timelines. Do NOT use this tool for custom project questions (e.g. "How much would it cost to build a custom app?"). It only returns providers' pre-defined, fixed-price packages, not a quote tailored to a specific project; use recommend_service_providers for those needs instead. Examples: - "Show me SEO packages" -> service="SEO" - "What web design packages can I get for $5,000?" -> service="Web Design", budget=5000 - "Marketing packages from agencies in New York" -> service="Digital Marketing", location="New York" Use `page`/`limit` for pagination.ConnectorNo auth
- Create a database user for a Cloud SQL instance. * This tool returns a long-running operation. Use the `get_operation` tool to poll its status until the operation completes. * When you use the `create_user` tool, specify the type of user: `CLOUD_IAM_USER`, `CLOUD_IAM_SERVICE_ACCOUNT`, or `BUILT_IN`. * By default the newly created user is assigned the `cloudsqlsuperuser` role, unless you specify other database roles explicitly in the request. * You can use a newly created user with the `execute_sql` tool if the user is a currently logged in IAM user. The `execute_sql` tool executes the SQL statements using the privileges of the database user logged in using IAM database authentication. The `create_user` tool has the following limitations: * To create a built-in user with password, use the `password_secret_version` field to provide password using the Google Cloud Secret Manager. The value of `password_secret_version` should be the resource name of the secret version, like `projects/12345/locations/us-central1/secrets/my-password-secret/versions/1` or `projects/12345/locations/us-central1/secrets/my-password-secret/versions/latest`. The caller needs to have `secretmanager.secretVersions.access` permission on the secret version. * The `create_user` tool doesn't support creating a user for SQL Server. To create an IAM user in PostgreSQL: * The database username must be the IAM user's email address and all lowercase. For example, to create user for PostgreSQL IAM user `example-user@example.com`, you can use the following request: ``` { "name": "example-user@example.com", "type": "CLOUD_IAM_USER", "instance":"test-instance", "project": "test-project" } ``` The created database username for the IAM user is `example-user@example.com`. To create an IAM service account in PostgreSQL: * The database username must be created without the `.gserviceaccount.com` suffix even though the full email address for the account is`service-account-name@project-id.iam.gserviceaccount.com`. For example, to create an IAM service account for PostgreSQL you can use the following request format: ``` { "name": "test@test-project.iam", "type": "CLOUD_IAM_SERVICE_ACCOUNT", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM service account is `test@test-project.iam`. To create an IAM user or IAM service account in MySQL: * When Cloud SQL for MySQL stores a username, it truncates the @ and the domain name from the user or service account's email address. For example, `example-user@example.com` becomes `example-user`. * For this reason, you can't add two IAM users or service accounts with the same username but different domain names to the same Cloud SQL instance. * For example, to create user for the MySQL IAM user `example-user@example.com`, use the following request: ``` { "name": "example-user@example.com", "type": "CLOUD_IAM_USER", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM user is `example-user`. * For example, to create the MySQL IAM service account `service-account-name@project-id.iam.gserviceaccount.com`, use the following request: ``` { "name": "service-account-name@project-id.iam.gserviceaccount.com", "type": "CLOUD_IAM_SERVICE_ACCOUNT", "instance": "test-instance", "project": "test-project" } ``` The created database username for the IAM service account is `service-account-name`.ConnectorNo auth
- Search FreeCV's LIVE index of real people who are open to work — by skills, role/title, location, and recruiter facets (work type, employment type, visa sponsorship, languages, minimum experience). Returns lean candidate cards (name, current role @ company, location, top skills, languages, and the full availability preferences) plus each person's cv.json URL and portfolio URL — enough to shortlist WITHOUT a fetch_cv per candidate. Call fetch_cv on a result to read the complete structured CV. Only already-public profiles are indexed; contact details are never returned (reach candidates via their portfolio).ConnectorNo auth
- Publish a post to the user’s connected LinkedIn profile — text, and optionally an image (pass its served URL as imageUrl). The image does NOT have to be something Hermoso generated: LinkedIn is served the bytes from us, so the URL must be Hermoso-hosted, and upload_file turns ANY file the user already has into exactly that. This PUBLISHES immediately and PUBLICLY — ALWAYS show the user the exact text and get an explicit yes BEFORE calling. Needs a connected LinkedIn account (Settings ▸ Connectors ▸ LinkedIn).ConnectorNo auth