Sumble

Add people to an existing contact list. Duplicates are silently skipped. Always share the list URL so the user can open it in Sumble. Workflow when a user provides names or LinkedIn URLs: 1. Call `FindMatchAndEnrichPeople` to resolve them to Sumble person IDs. 2. Call `AddContactsToList` with the matched IDs (use the "id" field from each result). If you already have Sumble person IDs (from a prior API call), pass them directly as people_ids. Args: reason: Why you are calling this tool. list_id: The contact list ID (from `ListContactLists` or `CreateContactList`). people_ids: Sumble person IDs to add.

AddContactsToList

Add organizations to an existing list. Pass Sumble organization IDs, slugs, or both. At least one is required. Workflow when a user provides company names or URLs: 1. Call `FindMatchAndEnrichOrganizations` to resolve them to Sumble IDs. 2. Call `AddOrganizationsToList` with the matched IDs (use the "id" field from each match result). If you already have Sumble org IDs (from a SQL query, FindMatchAndEnrichOrganizations, or another API call), skip step 1 and pass them directly as organization_ids.

AddOrganizationsToList

Create a new contact list (people list). Use `AddContactsToList` to populate it afterward. Always share the list URL so the user can open it in Sumble. Workflow when a user wants to build a people list: 1. Call `FindMatchAndEnrichPeople` to get Sumble person IDs. 2. Call `CreateContactList` to make the list. 3. Call `AddContactsToList` with the person IDs. If you already have Sumble person IDs (from a prior API call), skip step 1 and use those IDs directly. Always ask the user for the list name. If you have a good guess, you can suggest it in the prompt. Args: reason: Why you are calling this tool. name: Name for the new list.

CreateContactList

Create a new organization list. Use `AddOrganizationsToList` to populate it afterward. Always share the list URL with the user so they can view it in the dashboard. Workflow when a user provides company names or URLs: 1. Call `FindMatchAndEnrichOrganizations` to resolve them to Sumble IDs. 2. Call `CreateOrganizationList` to make the list. 3. Call `AddOrganizationsToList` with the matched IDs. If you already have Sumble org IDs (from a SQL query, FindMatchAndEnrichOrganizations, or another API call), skip step 1 and use those IDs directly. Always ask the user for the list name to use. If you have a good guess for the name, you can suggest it in the prompt. Do not create a new list just to change an existing list's name. Use `RenameOrganizationList` so the list keeps its id, URL, and organizations.

CreateOrganizationList

The primary jobs tool: look up jobs by id or search the jobs corpus, and return exactly the attributes you ask for, with optional related people. INPUT — provide EXACTLY ONE of: - `jobs` (list mode): up to 1000 entries, each {"job_id": <int>}. One result row per entry, in input order; entries that don't match a Sumble job come back with just their input echoed and cost nothing. - Filter mode: any of `organization_ids`, `organization_list_id`, and/or `query` (at least one required). With no organization scope the whole jobs corpus is searched. `limit`/`offset` apply to filter mode only. ORGANIZATION SCOPING (filter mode) — there is no name/domain org param. To scope to specific companies, first resolve names or domains to ids with FindMatchAndEnrichOrganizations (whose free attributes include `id`) and pass `organization_ids`. The query language's `organization EQ '<name>'` node is a fuzzy single-org match and can pick the wrong company — prefer explicit ids. For saved lists prefer the `organization_list_id` param over the query language's `organizations_list` field. SELECT — `attributes`. Every row always includes job_id and a sumble_url deep link for free, plus the free attributes (title). Paid attributes (1 credit each per returned job): description, location, posted_date, organization, technologies, teams, job_functions, job_levels, projects. `description` is the full posting text; selecting it allows at most 200 jobs per request in list mode. RELATED PEOPLE — pass `related_people` as {"attributes": [...], "limit": N} to also get the people likely involved in each job's hiring: scored hiring managers and team members at the posting organization, inferred from team, job function, location and technology similarity, not actual reporting lines. Available in BOTH modes, for at most 25 jobs per request (list entries or `limit`). Per-job limit is 1-25 (default 5); 1 credit per related person returned. Related people support the person attributes (name is free; linkedin_url, job_title, job_function, job_level, location, country, current_employer, technologies) except email/phone. COST — total = returned jobs x (1 + paid attributes) + related people returned. The API checks affordability up front and returns an error before doing any work the user can't pay for. A request whose worst-case cost is above 500 credits is refused and nothing is charged unless `allow_expensive_query` is true. Confirm the spend with the user before setting it, once per call: a confirmation never carries over to the next page, a refined query, or any other call. When asking, offer a cheaper sample as an alternative: the same request with a small `limit` (filter mode) or a handful of entities (match mode), so the user can check the results before paying for all of them. Always share sumble_url links with the user. Filter mode also returns a `source_data_url` linking to the matching jobs on Sumble (present when no org scope or exactly one org is given) — share it with the user too. QUERY SYNTAX (use `query` param): Operators: EQ, NEQ, IN, NOT IN. Combine with AND, OR. Group with parentheses. Values are single-quoted. IN/NOT IN use comma-separated values in parens. Available fields: ORGANIZATION / SCOPE FIELDS — filter which orgs to search jobs within: - organizations_list — EQ/IN. Restrict to a user's saved org list by numeric list ID. Use ListOrganizationLists to get IDs first. Use 'default' for the user's default list. Example: organizations_list EQ '42' - organization — EQ only. Fuzzy org name/URL. - industry — EQ/IN/NOT IN. - employee_count — EQ/IN. Range format: '100-1000', '1000-' (1000+), '-500'. - hq_location — EQ/IN/NEQ. Format: 'US', 'US:Texas', 'US:Texas:Austin'. Region codes: EMEA, APAC, NAMER, LATAM. - tag — EQ/IN (e.g. 'digital_native'). - funding_last_round_type — EQ/IN/NEQ/NOT IN. Values: 'pre_seed', 'seed', 'series_a' through 'series_h', 'series_h_plus', 'debt', 'grant', 'convertible_note', 'private_equity'. 'series_h_plus' is a virtual value that matches Series I and beyond (series_i..series_z under the hood). Raw 'series_i'..'series_z' are NOT accepted as filter values — use 'series_h_plus' instead. - funding_last_round_year — EQ. Range format like employee_count: '2022-2025', '2023-', '-2020'. - funding_last_round_raised — EQ. USD amount raised in the most recent round. Range format: '1000000-50000000', '100000000-', '-5000000'. - funding_total_raised — EQ. Range format in USD: '1000000-50000000', '100000000-', '-5000000'. - funding_valuation — EQ. Post-money valuation in USD. Range format: '10000000-1000000000', '1000000000-', '-50000000'. JOB FIELDS — filter which jobs to return: - technology — EQ/IN/NOT IN. Use slugs from SearchTechnologies. - technology_category — EQ/IN/NOT IN (e.g. 'gen-ai', 'mlops', 'cybersecurity'). - project — EQ/IN. Filter by project slug. Example: project IN ('cloud-migration', 'gen-ai-initiative') - job_function — EQ/IN/NOT IN (e.g. 'Machine Learning', 'Data Scientist', 'Engineer', 'Product Manager'). - job_level — EQ/IN/NOT IN (e.g. 'Senior', 'Manager', 'VP', 'Director'). - country — EQ/IN/NOT IN. Format: 'US', 'US:California', 'US:California:San Francisco'. Use full state names, not abbreviations. 'UK' is auto-converted to 'GB'. - hiring_period — EQ ONLY (not IN/NOT IN). Values: '2wk', '1mo', '3mo', '6mo', '1yr', '18mo', '2yr'. - NOTE: job_title and job_description are NOT available as filters. Use job_function and job_level. COMBINING FILTERS: Use AND to combine org fields with job fields. Do NOT use OR across org and job fields. Examples: - Jobs in a user's org list with specific tech: organizations_list EQ '42' AND technology IN ('snowflake', 'databricks') - Jobs in default list, ML roles, recent: organizations_list EQ 'default' AND job_function EQ 'Machine Learning' AND hiring_period EQ '3mo' - Jobs at large US companies using PyTorch: technology EQ 'pytorch' AND hq_location EQ 'US' AND employee_count EQ '1000-' - Jobs matching a project and function: project EQ 'cloud-migration' AND job_function IN ('Cloud Engineer', 'DevOps Engineer') - Basic tech + location: technology IN ('pytorch', 'tensorflow') AND country EQ 'US' - Function + level: job_function IN ('Machine Learning', 'AI Engineer') AND job_level EQ 'Senior' Args: reason: Why you are calling this tool. jobs: List mode entries, each {"job_id": <int>}. Mutually exclusive with the filter-mode params. organization_ids: Filter mode: Sumble organization ids to search within (at most 1000). organization_list_id: Filter mode: id of one of the user's saved organization lists. query: Filter mode: advanced query string. See QUERY SYNTAX. attributes: Job attributes to return (the free ones are always included). related_people: Optional related-people selection. limit: Max results, filter mode only (1-200, default 10). offset: Skip N results, filter mode only (default 0). allow_expensive_query: Set to true only after the user has confirmed this call's cost. One confirmation covers one call.

FindMatchAndEnrichJobs

Find, match, and enrich organizations in one call. This is the primary organizations tool. It resolves organizations and returns the exact baseline attributes and per-entity metrics you ask for. Provide EXACTLY ONE of: - organizations: a list of companies to resolve (match) by id, slug, name, url, and/or location, OR - query: an advanced-query string that selects organizations (search / filter mode). Leave the other one out. An empty list or an empty string is read as "not provided", so a host that fills every parameter still lands in the right mode. If results include URLs or links, always share them with the user. WHAT YOU GET BACK Each result row echoes its input and includes: - attributes: the baseline company fields you requested (null if the org could not be matched), and - entities: one result block per entity selection, with the requested metrics (and deep-link URLs). INPUT — organizations (match mode) A list of up to 1000 dicts. Each dict needs at least one of: - id: Sumble organization id (int) — bypasses matching - slug: Sumble slug (str) — bypasses matching - name: company name (str) - url: website or domain (str) - location: country name or code (str, optional; improves matching accuracy) Example: [{"name": "Sumble", "url": "sumble.com"}, {"id": 1726684}] INPUT — query (search / filter mode) An advanced-query string (syntax below). Use limit/offset to page and order_by_column/order_by_direction to sort. order_by is ONLY valid in this mode. Special sorts: - "people_concentration": all-time fraction of the org's tracked people in one job function. REQUIRES order_by_job_function (a job function name, e.g. "Data Engineer"; 400 if unknown). - "people_count_growth_1y": current YoY % growth of the org's people in one job function (latest month vs. one year earlier); orgs without growth data sort last in both directions. REQUIRES order_by_job_function. - "job_post_concentration": all-time fraction of the org's job posts matching a second advanced query. REQUIRES order_by_advanced_query (advanced-query syntax below, restricted to technology, technology_category, job_function, project, job_level, country; no excludes). The sort query only orders results — it does NOT filter them; orgs with no matching jobs sort as 0. The webapp cannot reproduce these orderings, so the response has no source_data_url for these sorts. Search results exclude permanently closed organizations by default; set include_closed=true to include them. Match mode always resolves closed organizations. Request the paid status/status_reason attributes to see which returned organizations are closed and why. SELECT — attributes A list of baseline fields to return. The free fields (id, name, slug, url, sumble_url) are ALWAYS returned automatically — you only need to list the paid attributes you want here. Each of these costs 1 credit per matched org: employee_count, industry, jobs_count, teams_count, jobs_count_rollup, jobs_count_no_rollup, teams_count_rollup, teams_count_no_rollup, people_count_rollup, people_count_no_rollup, headquarters_country, sumble_score, parent_id, subsidiary_ids, tags, status, status_reason, funding_total_raised, funding_valuation, funding_last_round_raised, funding_last_round_type, funding_last_round_date. `sumble_score` is Sumble's proprietary account-fit score for the CURRENT user's company / ICP (see caveat below). `account_status` is free (no credit cost) but NOT auto-included — request it explicitly. Values: 'customer', 'prospect', 'not_in_crm' — the CRM relationship between the org and the CALLING account (a customer account in your CRM, tracked in CRM but not a customer, or not in CRM at all). Only populated when the calling account has a linked CRM seat (Salesforce or HubSpot); 403 if requested without one. Also usable as a `query` filter field — see ADVANCED QUERY SYNTAX. SELECT — entities A list of per-entity metric selections. Each entity is a dict: - type (required): one of technology, job_function, project, technology_category, advanced_query - term (required): the slug / name / category slug / advanced-query string for that type - metrics (required): a list of metric names valid for the type, or the string "all" - granularity: REQUIRED for technology_category (and only valid there). "aggregate" rolls the category up into one set of counts; "exploded" returns per-component- technology counts (and multiplies cost by the number of component technologies). - since: optional YYYY-MM-DD; scopes job_post_count, job_post_used_count, team_count, and people_count to activity on/after this date. Does not affect *_growth_1y. The *_no_rollup metrics count only the organization's own records (subsidiaries excluded), pairing with the rollup counts so you can compute record-scope shares. They are all-time only: excluded from "all" when `since` is set, and rejected if requested explicitly alongside `since`. Valid metrics by type: - technology: job_post_count, job_post_used_count, people_count, team_count, job_post_count_growth_1y, job_post_count_no_rollup, team_count_no_rollup, people_count_no_rollup - job_function: job_post_count, team_count, people_count, people_count_growth_1y, job_post_count_growth_1y, people_concentration (fraction 0-1 of the org's tracked people in the job function; `since` scopes both the matching and total people counts), job_post_count_no_rollup, team_count_no_rollup, people_count_no_rollup - project: job_post_count, team_count, job_post_count_no_rollup, team_count_no_rollup - advanced_query: job_post_count, team_count, people_count, job_post_concentration (fraction 0-1 of the org's job posts matching the query; `since` scopes both the matching and total job counts) - technology_category: job_post_count, people_count, team_count, job_post_count_growth_1y (growth available only with granularity "exploded") Entity examples: - {"type": "technology", "term": "kubernetes", "metrics": "all"} - {"type": "technology_category", "term": "gen-ai", "metrics": ["job_post_count"], "granularity": "aggregate"} - {"type": "job_function", "term": "Data Engineer", "metrics": ["people_count"], "since": "2024-01-01"} TECHNOLOGY CATEGORY SLUGS (commonly used): crm, business-intelligence, cloud-data-warehouse, data-catalog, gen-ai, mlops, ml-training, cybersecurity, cloud-security, ci-cd, ipaas, event-streaming, data-pipeline-orchestration, etl, logging-observability-monitoring, data-quality-and-observability, customer-data-platform, feature-flagging-and-a-b-testing, vector-database, oss-data-science, commercial-data-science, infrastructure-as-code-tools, design, javascript, siem, edr, headless-cms, ccaas, endpoint-management, ecommerce-platform, vibe-coding, coding-agents, marketing-automation-platforms, frontier-ai-models, processing-units-and-chips, cloud-and-container-orchestration-platforms, identity-and-access-management ADVANCED QUERY SYNTAX (used for the `query` param and for `advanced_query` entity terms): Operators: EQ, NEQ, IN, NOT IN. Combine with AND, OR. Group with parentheses. Values are single-quoted. IN/NOT IN use comma-separated values in parens. LIMITATION: negation (NEQ / NOT IN) is only supported on industry, hq_location and organizations_list (as listed per field below). Negating any other field (e.g. technology) fails the whole query with 400 Invalid query. Available fields: - technology — EQ/IN only (no NOT IN). Use slugs from SearchTechnologies. - technology_category — EQ/IN only (no NOT IN). Slugs from the list above. - organization — EQ only. Fuzzy name/URL match. - organizations_list — EQ/IN/NOT IN. Values are numeric organization-list IDs as single-quoted strings (e.g. '12345'). Use this field to search orgs within a user's accounts, which can be retrieved via ListOrganizationLists. Use 'default' for the user's default list. Important: organizations_list must be a top-level clause, not nested within another clause/parentheses. - account_status — EQ/NEQ only, single value (no IN). Values: 'customer', 'prospect', 'not_in_crm'. The CRM relationship between the org and the CALLING account, same as the return attribute above. Requires the calling account to have a linked CRM seat — 403 otherwise. - industry — EQ/IN/NOT IN. - employee_count — EQ/IN. Range format: '100-1000', '1000-' (1000+), '-500' (up to 500). - hq_location — EQ/IN/NEQ. Format: 'US', 'US:Texas', 'US:Texas:Austin'. Use full state names, not abbreviations. 'UK' is auto-converted to 'GB'. Region codes: EMEA, APAC, NAMER, LATAM, Americas, Europe, MiddleEast, Africa. Use SearchLocations to find valid codes by name or list a location's children. - tag — EQ/IN. Valid slugs: 'is_ai_native', 'acquired_and_absorbed', 'b2b', 'b2c', 'closed', 'digital_native', 'freelancing', 'org_type_government', 'org_type_hospital', 'it_services', 'org_type_k12_school', 'org_type_nonprofit', 'is_private_equity_firm', 'is_private_equity_owned', 'professional_services', 'is_public_company', 'org_type_recruitment_agency', 'spinout', 'is_soe', 'org_type_university', 'is_venture_backed'. Tags are curated, exact-match labels. When the user's intent maps to one of these tags (e.g. "digital native companies" → 'digital_native'), use the tag field rather than industry, SIC code, or free-text terms. - sic_code — EQ (e.g. '7371'). - naics_code — EQ (e.g. '541511'). - funding_last_round_type — EQ/IN only (no NEQ/NOT IN). Values: 'pre_seed', 'seed', 'series_a' through 'series_h', 'series_h_plus', 'debt', 'grant', 'convertible_note', 'private_equity'. 'series_h_plus' is a virtual value that matches Series I and beyond (series_i..series_z under the hood). Raw 'series_i'..'series_z' are NOT accepted as filter values — use 'series_h_plus' instead. - funding_last_round_year — EQ. Range format like employee_count: '2022-2025', '2023-', '-2020'. - funding_last_round_raised — EQ. USD amount raised in the most recent round. Range format: '1000000-50000000', '100000000-', '-5000000'. - funding_total_raised — EQ. Range format in USD: '1000000-50000000', '100000000-', '-5000000'. - funding_valuation — EQ. Post-money valuation in USD. Range format: '10000000-1000000000', '1000000000-', '-50000000'. - primary_<category> — EQ/IN only (no NOT IN). Filter by an org's primary (dominant) technology within a specific category. Field name is "primary_" + the category slug with hyphens replaced by underscores. Examples: cloud-vendor -> primary_cloud_vendor cloud-data-warehouse -> primary_cloud_data_warehouse Values are technology slugs. Use '__none__' to find orgs with NO primary tech in a category. Only use when the user expresses dominance intent ("primary", "main", "standardized on"). Must be combined with a matching technology_category clause, or a technology clause whose technology belongs to that same category. IMPORTANT: Do NOT combine org filters with job filters (job_function, job_level, country) using OR. Query examples: - technology IN ('snowflake', 'databricks') AND employee_count EQ '1000-' - hq_location IN ('US:California', 'US:New York') - hq_location EQ 'EMEA' - technology EQ 'kubernetes' AND hq_location EQ 'US' AND employee_count EQ '1000-5000' - industry NOT IN ('Recruiting and Staffing') - organizations_list IN ('12345', '67890') - technology_category EQ 'cloud-data-warehouse' AND primary_cloud_data_warehouse EQ 'snowflake' Note: this tool is not the same as `ListOrganizationLists` and `GetOrganizationList`. Those tools are specifically for retrieving a user's accounts, and are good in combination with this tool (search within accounts via the `organizations_list` filter field). COST Total = matched_count × per-org cost. Per-org cost = 1 (base) + 1 per paid attribute + (metric count × explosion) per entity. `metrics: "all"` counts as every metric for that type; an exploded technology_category fans out by its component-tech count. This can get expensive — confirm with the user before large org lists or many attributes/entities. A request whose worst-case cost is above 500 credits is refused and nothing is charged unless `allow_expensive_query` is true. Confirm the spend with the user before setting it, once per call: a confirmation never carries over to the next page, a refined query, or any other call. When asking, offer a cheaper sample as an alternative: the same request with a small `limit` (filter mode) or a handful of entities (match mode), so the user can check the results before paying for all of them. ACCOUNT SCORE CAVEAT `sumble_score` (and ordering by account_score) is a proprietary score reflecting fit to the CURRENT user's company, products, and ICP.

FindMatchAndEnrichOrganizations

The primary people tool: resolve people and return exactly the attributes you ask for, with optional related people and contact reveals. TIMING — requests run as background jobs, but this tool waits for the result server-side, so most calls (all filter-mode queries, and match mode without contact reveals) return the finished result directly, like a normal tool call. When a request needs longer (contact reveals can take a few minutes), the response instead carries `status: "running"` and a `request_id`. Call this tool again with ONLY `request_id` to keep waiting — each such call waits up to ~35 seconds and returns either the finished result or `status: "running"` again; keep calling until you get a terminal status, and between calls do other useful work or update the user. Don't start a duplicate request while one is still running. `failed` means the lookup failed server-side and nothing was charged; you may retry once with a fresh request, and if that also fails, tell the user. The rare `not_found` status means the request timed out server-side — treat it like `failed`. An unknown or expired request_id returns an error. Input validation and affordability are checked when the request starts, so bad requests and insufficient credits still fail immediately. INPUT — provide EXACTLY ONE of: - `people` (match mode): up to 1000 entries, each identified by any of `person_id`, `linkedin_url`, and/or `email` (precedence: person_id > linkedin_url > email). One result row per entry, in input order; entries that don't match come back with just their input echoed and cost nothing. - Filter mode: `organization_ids` and/or `organization_list_id` (REQUIRED — people queries are organization-scoped; resolve names or domains to ids with FindMatchAndEnrichOrganizations first, whose free attributes include `id`) plus an optional `query` (see QUERY SYNTAX). `limit`/`offset` apply to filter mode only. SELECT — `attributes`. Every row always includes person_id, name, and a sumble_url deep link for free. Paid attributes (1 credit each per returned person): linkedin_url, job_title, job_function, job_level, location, country, current_employer (the employer org with its Sumble organization_id, slug, start date, and link), technologies (from the person's profile skills, normalized to Sumble's technology catalog, as name+slug objects), experience and summary (see below), person_score (see below). PROFILE — `experience` (1 credit) is the person's full LinkedIn-style role history, newest first: title, start_date/end_date (YYYY-MM), duration, location, the person's own description of the role, and an employer shaped like current_employer (organization_id, slug, and sumble_url when Sumble knows the organization, plus the employer's name and linkedin_url from the profile). `summary` (1 credit) is the profile's "About" section as the person wrote it. Both work in either mode (a match-mode request is capped at 200 people) and are never part of "all" — ask for them by name when the user wants a person's background or career path rather than just their current role. PERSON SCORE — `person_score` (1 credit) rates each person 0-100 against the user's ideal customer profile (ICP), with skill, job-function, and seniority contributions plus the matched technologies/job functions behind them. Filter mode only, and requires exactly ONE organization in scope and an ICP configured for the user's account — requests that don't meet this fail with a 400 explaining why. When selected, results come back ordered by the score, best leads first. Use it to rank the people at a target account. CONTACT REVEALS — `email` (10 credits) and `phone` (80 credits) are also selectable attributes, charged once per person on the first successful reveal; repeat reveals and not-found lookups are free. Match mode only, at most 25 people per request. EMAIL IDENTIFIERS — an entry identified only by email is resolved via reverse enrichment: +20 credits when it resolves to a returned person, free otherwise. At most 25 people per request when used. RELATED PEOPLE — pass `related_people` as {"direction": ["managers" and/or "direct_reports"], "attributes": [...]} to also get people up or down the org hierarchy for each matched person. Match mode only, at most 25 people per request, 1 credit per related person returned. Relationships are INFERRED from org structure and seniority signals, not actual reporting lines. Related people support the same attributes except email/phone, experience/summary, and person_score. COST — total = matched_count x (1 + paid attributes) + related people + contact reveals + email resolutions. The API checks affordability up front and returns an error before doing any work the user can't pay for. Credits are charged once, on the response that first returns the succeeded result — its `credits_used` is what was charged; kickoff and still-running responses report `credits_used: 0`. A request whose worst-case cost is above 500 credits is refused and nothing is charged unless `allow_expensive_query` is true. Confirm the spend with the user before setting it, once per call: a confirmation never carries over to the next page, a refined query, or any other call. When asking, offer a cheaper sample as an alternative: the same request with a small `limit` (filter mode) or a handful of entities (match mode), so the user can check the results before paying for all of them. LINKING A PERSON — `sumble_url` is the primary link for every person, including related people, and it is free. When `linkedin_url` was also selected, it is the secondary link: offer it alongside the Sumble profile, never in place of it. Always share sumble_url links with the user. JOB FUNCTIONS (top-level categories with children): - Executive, Board of Directors - Engineering & R&D: Data Analyst, Statistician, Data Scientist, Machine Learning (incl. MLOps Engineer), AI Engineer, Researcher, Engineer (Software Engineer, Security Engineer, DevOps Engineer, Data Engineer, Site Reliability Engineer, Cloud Engineer, etc.), Applied Scientist, Scientist - Product & Design: Product Manager, Designer (UX, Visual, Brand, etc.) - Strategy & Operations: Analyst, Strategy, Operations (Program Manager, Procurement & Supply Chain) - Information Technology: IT Support, IT Security, Business Systems, etc. - Healthcare Services: Physician, Nurse, Pharmacist - Sales: Account Executive, SDR - Marketing: Product Marketing, Growth, Content, Digital Marketing - Customer Support, Customer Success, Solutions - Revenue Operations (GTM Engineer) - Business Development - General & Administrative: Finance (Accountant, Financial Analyst), Legal & Compliance, Human Resources, Administrator - Consultant, Government, Education, Journalist JOB LEVELS (highest to lowest rank): Board Member, CXO, EVP, CVP, SVP, RVP, AVP, VP, Executive Director, Senior Director, Director, General Manager, Head, Associate Director, Senior Manager, Manager, Principal, Lead, Senior, Individual Contributor QUERY SYNTAX (use `query` param): Operators: EQ, NEQ, IN, NOT IN. Combine with AND, OR. Group with parentheses. Values are single-quoted. IN/NOT IN use comma-separated values in parens. Available fields: - job_function — EQ/IN/NOT IN. Use values from the JOB FUNCTIONS list above. - job_level — EQ/IN/NOT IN. Use values from the JOB LEVELS list above. - country — EQ/IN/NOT IN. Format: 'US', 'US:California', 'US:California:San Francisco'. Use full state names, not abbreviations. 'UK' is auto-converted to 'GB'. - technology — EQ/IN/NOT IN. Use slugs from SearchTechnologies. - since — EQ ONLY. ISO date format: '2023-01-01'. Returns people with data since that date. - hiring_period — EQ ONLY. Predefined buckets: '2wk', '1mo', '3mo', '6mo', '1yr', '18mo', '2yr'. Alternative to `since` for relative ranges. - person_name — EQ. - NOTE: job_title and job_description are NOT available as filters. Use job_function and job_level. Examples: - ML engineers in the US: job_function IN ('Machine Learning', 'AI Engineer') AND job_level IN ('Senior', 'Lead') AND country EQ 'US' - Data scientists in California: job_function EQ 'Data Scientist' AND country EQ 'US:California' - Senior PyTorch users: technology EQ 'pytorch' AND job_level EQ 'Senior' - Recent engineering hires: job_function EQ 'Engineer' AND since EQ '2026-01-01' - VPs in the UK: job_level EQ 'VP' AND country EQ 'UK' Args: reason: Why you are calling this tool. request_id: Resume waiting on a still-running request. When provided, all other arguments are ignored. people: Match mode entries. Mutually exclusive with the filter-mode params. organization_ids: Filter mode: Sumble organization ids to search within (at most 1000 combined with the list). organization_list_id: Filter mode: id of one of the user's saved organization lists. query: Filter mode: advanced query string. See QUERY SYNTAX. attributes: Person attributes to return (the free ones are always included). related_people: Optional related-people selection. limit: Max results, filter mode only (1-200, default 10). offset: Skip N results, filter mode only (default 0). allow_expensive_query: Set to true only after the user has confirmed this call's cost. One confirmation covers one call.

FindMatchAndEnrichPeople

Check your API key and account status. Free (no credits used). Further account details are available at https://sumble.com/account

GetAccountInformation

Get one contact list and its people. Fetch a list by id after calling `ListContactLists`. Contact information is present only for enriched contacts. Always share the list URL and the relevant person URLs with the user. Each person carries a `url` (their Sumble profile) and a `linkedin_url`: link the person by their Sumble `url`, and treat LinkedIn as secondary, offered alongside rather than instead. Costs 1 credit per returned person. A list of more than 500 people is refused and nothing is charged unless `allow_expensive_query` is true. Confirm the spend with the user before setting it, once per call: a confirmation never carries over to any other call. When the user asks to download the list as CSV, pass `file_name`. Ask Sumble and Slack attach the file automatically. In other MCP clients, present the authenticated Sumble download URL to the user. The response retains request, credit, and list metadata and describes the file's kind, row count, columns, and size, but omits the person rows. Do not recreate the file with code execution. Args: list_id: The contact list ID (from `ListContactLists`). reason: Why you are calling this tool. file_name: When set to a .csv filename, save the people as a downloadable file instead of returning their rows. allow_expensive_query: Set to true only after the user has confirmed this call's cost. One confirmation covers one call.

GetContactList

Get a sales intelligence brief for a target account. The brief is LLM-generated: it is a natural-language sales narrative synthesized by Google Gemini from Sumble's structured data (technology, people, team, and signal records). Treat it as an AI-written summary — it may phrase, infer, or emphasize beyond the underlying records. Use this when the user asks for account research, sales prep, prospecting angles, who to contact, relevant technology signals, team fit, or recent changes at a company. The brief is written for the user's own company/domain, so it explains why this target account may matter to the user's GTM motion. The response includes a Markdown body and a Sumble URL. The body combines sections such as: What's the Angle, Who To Contact First, The Intel, Which Teams Are The Best Fit, and Recent Changes. If the response includes `sumble_url`, share it with the user. This tool requires a Sumble organization ID. If the user gives a company name, domain, or slug, first use FindMatchAndEnrichOrganizations to resolve it to an organization ID. The tool waits while a brief is being generated. If generation does not finish within 45 seconds, it returns an error asking you to call GetIntelligenceBrief again for the same organization. Calling again is free: credits are charged only for a completed brief, so retry rather than handing the wait back to the user. Costs 50 credits when a completed brief is returned. Args: reason: Why you are calling this tool. organization_id: The ID of the organization to get an intelligence brief for.

GetIntelligenceBrief