DataForB2B MCP Server
OfficialClick on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@DataForB2B MCP ServerFind me CTOs at Series B AI startups in Berlin for outreach"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
DataForB2B MCP Server
An MCP server for the DataForB2B API — search and enrich companies and people (professional profiles), job postings, and social posts, directly from Cursor, Claude, or any other MCP-compatible client.
Tools
Tool | Description |
| Search professional profiles with structured filters (title, company, location, skills, funding stage, ...). |
| Search companies with structured filters (industry, size, country, funding, hiring, ...). |
| Search job postings on LinkedIn / Indeed — hiring signals. |
| Search social posts on LinkedIn / Twitter / Reddit by keyword, or fetch a single post's engagers as leads. |
| Enrich a single profile (full profile data, work email, personal email, GitHub). |
| Enrich a single company (description, headquarters, employee count, funding, offices). |
Full parameter reference: docs.dataforb2b.ai/api-reference.
Related MCP server: DataLayer MCP
Getting an API key
Sign up at dataforb2b.ai and grab your API key from the dashboard.
Install
Requires Python 3.10+. The recommended way to run it is with uvx, which needs no separate install step and always runs the latest commit on main:
uvx --from git+https://github.com/DataForB2B/dataforb2b-mcp dataforb2b-mcpOr clone and install it with pip:
git clone https://github.com/DataForB2B/dataforb2b-mcp.git
pip install ./dataforb2b-mcpOnce published on PyPI, this collapses to plain
uvx dataforb2b-mcp/pip install dataforb2b-mcp(the config examples below use the git form, which works right now).
Configure
Cursor
Add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):
{
"mcpServers": {
"dataforb2b": {
"command": "uvx",
"args": ["--from", "git+https://github.com/DataForB2B/dataforb2b-mcp", "dataforb2b-mcp"],
"env": {
"DATAFORB2B_API_KEY": "your-api-key"
}
}
}
}Claude Desktop / Claude Code
Add to claude_desktop_config.json (Desktop) or run claude mcp add (Claude Code), using the same shape:
{
"mcpServers": {
"dataforb2b": {
"command": "uvx",
"args": ["--from", "git+https://github.com/DataForB2B/dataforb2b-mcp", "dataforb2b-mcp"],
"env": {
"DATAFORB2B_API_KEY": "your-api-key"
}
}
}
}Any other MCP client
Same command/args/env shape as above — every MCP client that supports stdio servers reads it the same way. Alternatively, run the server yourself and point your client at the process:
DATAFORB2B_API_KEY=your-api-key uvx --from git+https://github.com/DataForB2B/dataforb2b-mcp dataforb2b-mcpor with the flag instead of the env var:
uvx --from git+https://github.com/DataForB2B/dataforb2b-mcp dataforb2b-mcp --api-key your-api-keyDevelopment
git clone https://github.com/dataforb2b/dataforb2b-mcp.git
cd dataforb2b-mcp
uv sync
DATAFORB2B_API_KEY=your-api-key uv run dataforb2b-mcpInspect the server interactively with the MCP Inspector:
DATAFORB2B_API_KEY=your-api-key npx @modelcontextprotocol/inspector uv run dataforb2b-mcpLicense
MIT
Available Tools
6 toolsenrich_companyCompany EnrichmentARead-onlyIdempotent
Enrich a single company with full data from public sources (description, industry, headquarters, employee count, funding, offices, etc.).
| Name | Required | Description | Default |
|---|---|---|---|
| company_identifier | Yes | The company to enrich. Accepts any of: a universal_name slug (e.g. "google"), a LinkedIn company URL (e.g. "https://linkedin.com/company/google"), or an encoded DataForB2B ID (e.g. "org_xxx"). |
Output Schema
| Name | Required | Description |
|---|---|---|
| error | No | HTTP-style status code, present only when the call failed. |
| detail | No | Error message, present only when the call failed. |
| company | No | Full company data (description, industry, headquarters, employees, funding, offices, etc.). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds behavioral context by specifying the data comes from public sources and enumerates fields (description, industry, headquarters, employee count, funding, offices), which helps set expectations about what will be returned. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that clearly states the action and resource, followed by a parenthetical list of examples. Every word adds value and there is zero wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has one parameter with a fully descriptive schema and an output schema, so the description doesn't need to explain return values. It clearly communicates the single-company scope and the breadth of enrichment data. A slightly more explicit note about alternatives or limitations would make it complete, but it is already strong.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the schema already thoroughly describes the company_identifier parameter, including accepted formats. The description does not add additional parameter semantics beyond what the schema provides, matching the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb ('enrich') with a clear resource ('a single company') and specifies the type of data ('full data from public sources...'). This distinguishes it from siblings like search_company (which likely searches/finds companies) and enrich_profile (which enriches a person).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have a specific company identifier and need comprehensive enrichment data. However, it does not explicitly compare to alternatives like search_company or state when not to use it. The context 'single company' gives some guidance but no exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
enrich_profileProfile EnrichmentARead-onlyIdempotent
Enrich a single professional profile with detailed profile data, work email, personal email, and/or GitHub profile. Each enrichment flag controls one data source and bills separately.
| Name | Required | Description | Default |
|---|---|---|---|
| enrich_github | No | Find the person's GitHub profile URL. | |
| enrich_profile | No | Return the full profile object (experience, education, skills, etc.). | |
| enrich_work_email | No | Find the person's professional / work email. | |
| profile_identifier | Yes | The profile to enrich. Accepts any of: a LinkedIn URL (e.g. "https://linkedin.com/in/john-doe"), a public_id slug (e.g. "john-doe"), or an encoded DataForB2B ID (e.g. "prof_xxx"). | |
| enrich_personal_email | No | Find the person's personal email. |
Output Schema
| Name | Required | Description |
|---|---|---|
| error | No | HTTP-style status code, present only when the call failed. |
| phone | No | Phone number, when requested and found. |
| detail | No | Error message, present only when the call failed. |
| profile | No | Full profile object (experience, education, skills, etc.). |
| work_email | No | Professional / work email, when requested and found. |
| git_profile | No | GitHub profile data, when requested and found. |
| personal_email | No | Personal email, when requested and found. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior. The description adds valuable context beyond annotations by stating that each enrichment flag controls one data source and bills separately, warning about cost implications and independent data sources. This is useful behavioral information not present in the structured fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no fluff. The first sentence explains what the tool does, and the second provides an important billing/behavioral note. Every word earns its place, and it is front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the rich schema (100% parameter coverage), the presence of an output schema, and comprehensive annotations (readOnly, idempotent, openWorld), the description is complete. It covers the core purpose, the single-profile scope, and the billing behavior. Nothing critical is omitted.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameter semantics are fully documented in the schema. The description adds extra meaning by clarifying that each enrichment flag maps to a distinct data source and incurs separate billing, which is not evident from individual parameter descriptions. It also reinforces that the profile_identifier is the entry point.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool enriches a single professional profile with specific data types (detailed profile data, work email, personal email, GitHub profile). It uses a specific verb ('enrich') and resource ('single professional profile'), and the mention of 'single' differentiates it from search tools and sibling enrich_company.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use: when you have a specific profile identifier and want to enrich it. The phrase 'single professional profile' provides clear context, and the sibling enrich_company makes the distinction obvious. However, it does not explicitly state exclusions or mention alternatives like search_people for discovery.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_companySearch CompaniesARead-onlyIdempotent
Search companies using structured filters.
Use this for any company search: translate the user's intent (e.g. "AI startups in France that raised Series A") into structured filters on specific columns (industry, country, employee count range, funding stage, founded year, etc.). The available columns and operators are documented on the filters parameter.
Returns paginated companies matching ALL/ANY filter conditions depending on the op of the FilterGroup.
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | Number of companies to return (max 100; use offset to paginate further). | |
| offset | No | Pagination offset (number of results to skip). | |
| filters | Yes | Filter group: {"op": "and"|"or", "conditions": [<condition or nested group>, …]}; groups can be nested. Columns — basic info: name, tagline, description, domain, universal_name, keyword (full-text across name/tagline/description), industry · size & locations: employee_count, country_iso_code, city, region, office_country, office_city, office_region · growth: employee_growth_1m, employee_growth_6m, employee_growth_12m, recent_hires_count · metadata: founded_year, company_type, follower_count, page_verified, category · funding & investors: last_funding_amount_usd, last_funding_date, funding_stage_normalized, has_funding, investor · live job postings (hiring signal): job_title, job_location. Operators: =, !=, >, >=, <, <=, in, not_in, like, not_like, regex, between, is_null, is_not_null — semantics and per-column value formats are documented on the condition fields of the schema. Example — mid-size fintech/payments companies in the US or France: {"op":"and","conditions":[{"op":"or","conditions":[{"column":"category","type":"=","value":"fintech"},{"column":"description","type":"=","value":"payment processing"}]},{"column":"country_iso_code","type":"in","value":["US","FR"]},{"column":"employee_count","type":"between","value":50,"value2":500}]} | |
| order_by | No | Column to sort by, e.g. "follower_count", "employee_count", "founded_year", "last_funding_amount_usd". | |
| enrich_live | No | When true (1.5 credits/company), each company is enriched live from LinkedIn so data is fresh. When false (0.75 credits/company), data is served from the cached database — faster and cheaper. | |
| order_direction | No | Sort direction. | desc |
Output Schema
| Name | Required | Description |
|---|---|---|
| count | No | Number of companies returned in this page. |
| error | No | HTTP-style status code, present only when the call failed. |
| total | No | Total number of matching companies (estimate). |
| detail | No | Error message, present only when the call failed. |
| offset | No | Pagination offset of this page. |
| results | No | Matching company objects. |
| credits_used | No | Credits consumed by this search. |
| has_next_page | No | Whether more results are available. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond annotations: it returns paginated companies and that matching depends on the FilterGroup's op (ALL/ANY). This informs the agent about response shape and filter semantics without contradicting the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact: three sentences, front-loaded with the core purpose. It avoids restating schema details and instead directs the agent to the schema for specifics. Every sentence contributes to either identifying the tool's purpose or guiding its usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of nested filter groups and the richness of the input schema, the description sufficiently covers the tool's search semantics, pagination, and filter-group behavior. It leverages the schema's extensive field-level documentation rather than duplicating it. A minor gap is the lack of any mention of output schema or response fields, but the output schema is present and reduces the need for that in the description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds value by telling the agent to translate natural-language user intent into structured filters and by pointing to the filters parameter for available columns and operators. It also highlights the role of FilterGroup.op in combining conditions, which helps the agent construct valid filter objects.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Search companies using structured filters,' using a specific verb and resource that clearly distinguishes it from sibling tools like search_people or search_posts. It further reinforces the scope with 'Use this for any company search,' making the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'Use this for any company search' and provides concrete guidance on translating user intent into structured filters. It does not explicitly name alternatives or exclusion cases, but the sibling tools operate on different entities, so the usage context is clear enough for an agent to select it appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_jobsSearch Job PostingsARead-onlyIdempotent
Search job postings on LinkedIn or Indeed by keyword, location, and filters (employment type, remote/onsite, seniority, freshness, employer). Useful for hiring signals: which companies are recruiting for what roles, where.
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | Number of job postings to return. | |
| offset | No | Pagination offset. | |
| country | No | Country for Indeed (e.g. usa, france, uk, germany). Ignored by LinkedIn (uses location). | usa |
| keyword | No | Search keyword (job title, skill, company, ...). | |
| distance | No | Search radius in miles around the location. | |
| job_type | No | Employment type. | |
| location | No | Location, e.g. "Paris, France" or "United States". | |
| platform | No | Job platform to search. | |
| work_type | No | Work arrangement. | |
| company_ids | No | Comma-separated company ids to restrict the search (LinkedIn only). Accepts encoded org ids (org_xxx, as returned by search_company) and/or raw numeric LinkedIn ids. | |
| date_posted | No | Posting freshness. | |
| company_name | No | Company name to restrict the search. LinkedIn: resolved to the matching company (most-followed) — a strict employer filter. Indeed: used as the search keyword (approximate). Ignored if company_ids is provided. | |
| experience_level | No | Seniority (LinkedIn only). | |
| fetch_description | No | Include the full job description on each result (LinkedIn: slower; Indeed: no extra cost). |
Output Schema
| Name | Required | Description |
|---|---|---|
| count | No | Number of job postings returned in this page. |
| error | No | HTTP-style status code, present only when the call failed. |
| total | No | Number of job postings found so far (lower bound when has_next is true). |
| detail | No | Error message, present only when the call failed. |
| offset | No | Pagination offset of this page. |
| results | No | Job posting objects (title, company, location, salary, dates, description...). |
| has_next | No | Whether more results are available. |
| credits_used | No | Credits consumed by this search. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds the hiring-signal use case and platform scope but does not disclose additional behavioral traits such as pagination behavior, rate limits, or platform-specific response differences. It neither contradicts annotations nor enriches them significantly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two compact sentences with no filler. It front-loads the core action and resource, enumerates the main filter categories, and ends with a practical use-case sentence—each part earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the rich annotations (read-only, idempotent), a fully described 14-parameter schema, and the presence of an output schema, the description is sufficient for an agent to understand the tool's scope and value. The hiring-signal context adds orientation beyond what structured metadata provides, making the description complete for this complexity level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for all 14 parameters, including explicit per-parameter explanations and enum values. The description's filter list (employment type, remote/onsite, seniority, freshness, employer) simply restates a subset of the schema terms without adding new meaning or usage guidance beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Search' on 'job postings on LinkedIn or Indeed' and enumerates the key filter dimensions (keyword, location, employment type, remote/onsite, seniority, freshness, employer). It clearly distinguishes this tool from sibling tools like search_people, search_company, and search_posts by focusing on job postings and hiring signals.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides useful context about when to use the tool ('Useful for hiring signals: which companies are recruiting for what roles, where') and indicates the platforms it supports. It does not explicitly mention when not to use it or name alternative tools, but the sibling list and the clear platform/resource scope make the intended use obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_peopleSearch PeopleARead-onlyIdempotent
Search professional profiles using structured filters.
Use this for any people search: translate the user's intent (e.g. "AI engineers in Berlin who recently raised") into structured filters on specific columns (country, company size range, funding stage, etc.). The available columns and operators are documented on the filters parameter.
Returns paginated profiles matching ALL/ANY filter conditions depending on the op of the FilterGroup.
To find people at a SPECIFIC company you already identified (e.g. via search_company or enrich_company), filter on current_company_id (or past_company_id) with that company's id (e.g. "org_xxx") — NOT current_company (the name), which also matches other companies that happen to share the name and adds noise.
To target people by their COMPANY's business (e.g. "founders of AI sales-agent startups"), qualify the company itself: filter current_company_category (lowercase, holds precise niche values — "artificial intelligence", "sales automation", "saas") and/or current_company_industry, and when no category fits the niche, current_company_keyword (full-text on the employer's name/tagline/description — OR several "=" phrase variants). keyword searches the PERSON's own headline, so it fits attributes of the person themselves; for a company trait it matches unrelated people ("sales agent" → real-estate agents, sales reps).
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | Number of profiles to return (max 100; use offset to paginate further). | |
| offset | No | Pagination offset (number of results to skip). | |
| filters | Yes | Filter group: {"op": "and"|"or", "conditions": [<condition or nested group>, …]}; groups can be nested. Columns — profile: first_name, last_name, profile_location, profile_country, profile_industry, follower_count, keyword (headline full-text) · current job: current_company, current_title, current_job_location, current_company_industry, current_company_category, current_company_size, current_company_id, current_company_keyword (full-text on the employer's name/tagline/description), current_employment_type, years_in_current_position, years_at_current_company, current_company_has_funding, current_company_funding_stage, current_company_investor · past jobs: past_company, past_title, past_job_country, past_company_industry, past_company_size, past_company_id, past_employment_type, years_at_past_company · skills & education: skill, school, degree, degree_level, field_of_study · languages: language, language_iso, language_proficiency · certifications: certification, certification_authority · experience & contact: years_of_experience, num_total_jobs, is_currently_employed, has_email, has_phone. Operators: =, !=, >, >=, <, <=, in, not_in, like, not_like, regex, between, is_null, is_not_null — semantics and per-column value formats are documented on the condition fields of the schema. Example — fintech CEOs/founders in the US or UK: {"op":"and","conditions":[{"op":"or","conditions":[{"column":"current_title","type":"regex","value":"CEO"},{"column":"current_title","type":"like","value":"Founder"}]},{"column":"current_company_category","type":"=","value":"fintech"},{"column":"profile_country","type":"in","value":["US","GB"]}]} | |
| order_by | No | Column to sort by, e.g. "follower_count", "years_of_experience". | |
| enrich_live | No | When true (1.5 credits/profile), each profile is enriched live from LinkedIn so data is fresh. When false (0.75 credits/profile), data is served from the cached database — faster and cheaper. Default is false: live enrichment of many profiles is slow and can time out, so opt in only when freshness matters. | |
| order_direction | No | Sort direction. | desc |
| reveal_personal_email | No | When true, the actual personal_emails array is included on each result (extra credits per email revealed). When false, only the has_personal_email boolean flag is returned. |
Output Schema
| Name | Required | Description |
|---|---|---|
| count | No | Number of profiles returned in this page. |
| error | No | HTTP-style status code, present only when the call failed. |
| total | No | Total number of matching profiles (estimate). |
| detail | No | Error message, present only when the call failed. |
| offset | No | Pagination offset of this page. |
| results | No | Matching profile objects. |
| credits_used | No | Credits consumed by this search. |
| has_next_page | No | Whether more results are available. |
| total_is_capped | No | True if total reached the 10000 cap. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses key behavioral traits: pagination of results, ALL/ANY matching based on FilterGroup `op`, and the risk of matching unrelated companies when using `current_company` by name. It also warns that `keyword` searching on a company trait can return unrelated people, adding significant context beyond the readOnly/openWorld annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a one-line purpose, followed by logically separated paragraphs covering usage, pagination, and advanced filtering tips. While longer than a minimal description, each sentence carries practical weight for a tool with a complex nested filter schema, and the structure aids readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complex schema and rich output schema, the description covers the primary use cases, points to the schema for parameter details, and explains common pitfalls. It addresses pagination, group semantics, and specific intent translation (e.g., converting natural language to filters), making it complete for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides exhaustive detail on columns, operators, and value formats (100% coverage). The description adds strategic filter-construction semantics, such as using OR groups for same-column alternatives and choosing between `current_company_category` and `current_company_keyword` based on niche fit, which is not merely a restatement of the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Search professional profiles using structured filters,' clearly identifying the verb (search), resource (professional profiles), and method (structured filters). It distinguishes itself from sibling tools like search_company and search_posts by focusing exclusively on people search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states 'Use this for any people search' and provides actionable guidance such as using `current_company_id` instead of `current_company` to avoid noise, and contrasting `keyword` (person headline) with `current_company_keyword` (employer). It also references sibling tools (search_company, enrich_company) for obtaining company IDs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_postsSearch Social PostsARead-onlyIdempotent
Search social posts by keyword on LinkedIn, Twitter/X, or Reddit — or target a single post by URL. Great for intent signals: find people talking about a topic, then use include to attach the post's engagers (each reactor / commenter is a lead, with their profile).
Two modes:
Keyword search: set
keyword(+ optional filters).Single post: set
post_url(withincludeto get its engagers).
| Name | Required | Description | Default |
|---|---|---|---|
| count | No | Number of posts to return. | |
| match | No | 'strict' (default) keeps only posts whose text actually contains the searched terms; 'loose' returns the platform's raw results. | strict |
| offset | No | Pagination offset. | |
| include | No | Attach engagers to each returned post: any of ['reactions', 'comments']. Each engager is a lead. (Reddit exposes comments only — no upvoters.) | |
| keyword | No | Search keyword in post content. Required unless `post_url` is set. | |
| sort_by | No | Sort order. | date_posted |
| platform | No | Platform to search. | |
| post_url | No | Target a single post by URL instead of a keyword search. Use with `include` to get its engagers. | |
| subreddit | No | Reddit only: restrict the search to one subreddit (e.g. 'SaaS'). | |
| date_posted | No | Filter by post freshness. | |
| from_member | No | LinkedIn only: posts authored by this member URN (e.g. ACoAABxxxxxx). | |
| content_type | No | LinkedIn only: filter by content type. | |
| author_company | No | Filter by the post author's company name. | |
| author_industry | No | Filter by the post author's industry. | |
| author_job_title | No | Filter by the post author's job title. | |
| engagement_count | No | Max engagers per type, per post, when `include` is set. | |
| from_organization | No | LinkedIn only: posts authored by this organization id (numeric). |
Output Schema
| Name | Required | Description |
|---|---|---|
| count | No | Number of posts returned in this page. |
| error | No | HTTP-style status code, present only when the call failed. |
| total | No | Number of posts matching the search (lower bound when has_next is true). |
| detail | No | Error message, present only when the call failed. |
| offset | No | Pagination offset of this page. |
| results | No | Post objects (author, text, engagement counts, and engagers when `include` is set). |
| has_next | No | Whether more results are available. |
| credits_used | No | Credits consumed by this search. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds behavioral context beyond this: 'each reactor / commenter is a lead, with their profile' and that include attaches engagers, which is not evident from annotations alone.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise paragraphs, front-loaded with the core action, followed by a clear list of modes. No filler; every sentence contributes to understanding purpose or usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 17 parameters and an output schema, the description covers primary use cases (keyword search and single-post retrieval with leads). Platform-specific limitations like Reddit's comment-only engagers are in the schema. The description is sufficient for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for all 17 parameters, so the baseline is 3. The description adds high-level value by explaining the keyword vs post_url modes and the include/engager workflow, which helps an agent understand how parameters work together beyond individual schema entries.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Search social posts by keyword on LinkedIn, Twitter/X, or Reddit — or target a single post by URL' with specific verb+resource+scope. It distinguishes from sibling tools like search_people and search_company by focusing on posts and lead generation from engagers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context: 'Great for intent signals' and explains two modes (keyword vs URL) and the include option. However, it does not explicitly name alternatives or exclusion criteria like 'use search_people for profiles,' so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v0.1.0- First observed
enrich_company - First observed
enrich_profile - First observed
search_company - First observed
search_jobs - First observed
search_people - First observed
search_posts
TDQS
Each tool targets a distinct resource type (people, companies, posts, jobs) or a distinct action (search vs. enrich). The descriptions clearly differentiate search_people from enrich_profile and search_company from enrich_company, with no overlapping purposes.
All tool names follow a consistent verb_noun pattern: search_* for discovery and enrich_* for data augmentation. This predictable structure makes it easy to infer function from the name alone.
With 6 tools, the set is well-scoped for a B2B data platform. Each tool covers a distinct data operation (search people, companies, posts, jobs; enrich profiles, companies) without redundancy or bloat.
The tool surface covers the full expected lifecycle for a B2B data provider: discovery via search across all major entity types, and enrichment for deeper data on individuals and companies. No obvious dead ends or missing critical operations like retrieving by ID or exporting results.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Search companies, enrich contacts, and reveal emails and phones from your AI agent.
Real-time B2B data for agents: search and enrich 1B+ people and 200M+ company profiles.
LeadOracle - 7-tool B2B lead intel MCP: enrichment, scoring, intent signals, ICP fit.
The Google for AI agents — company intel, competitor tracking, market research via MCP. JSON output
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceBytemine MCP Server – Search 130M+ B2B contacts and enrich profiles with verified emails & phone numbers directly from Claude, Cursor, and other AI assistants via the Model Context Protocol.4-
- AlicenseAqualityDmaintenanceGive your AI agent access to 60M+ companies and 300M+ verified contacts. Enrich leads, find work emails, discover tech stacks, and identify buying intent — directly from Claude, Cursor, Windsurf, or any MCP-compatible AI agent.1127MIT
- AlicenseAqualityBmaintenanceEnables searching over 1 million enriched job listings from 20,000+ companies directly from MCP-compatible AI tools. Provides tools for job search, company profiles, and AI-powered similar job recommendations with real-time data updates.4722MIT
- FlicenseBqualityDmaintenanceExposes Apollo.io API functionalities as MCP tools for people and organization enrichment, search, and job postings. Enables natural language interaction with Apollo.io data.516-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/DataForB2B/dataforb2b-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server