Provides tools for searching business cards and contacts on the Eight platform, including registered/exchanged cards and public network people, with authentication and privacy controls.
Click on "Deploy 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., "@eight-mcp-community search for 佐藤 一郎 in registered cards"
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.
Unofficial Python client and stdio MCP server for Eight person-search workflows.
This project is unofficial and not affiliated with Eight or Sansan. It uses private/internal web endpoints that can change without notice. Keep cookies, credentials, and raw contact data out of GitHub, logs, issues, prompts, and public reports.
This package follows the same idea as note-mcp-community, but the core is Python:
PyPI/project name: eight-mcp-community
Python import package: eight
CLI commands: eight-mcp-community and eight-mcp
MCP server: stdio, suitable for local/private agent use
The core client is reusable without an LLM:
from eight import EightClient
client = EightClient.from_default_config()
result = client.search_person("鈴木太郎 東京商事")
print(result.to_safe_dict())The MCP server is a thin wrapper over the same EightClient.
Related MCP server: Prospeo MCP Server
Local development:
uv sync --dev
uv run eight-mcp-community --help
uv run eight-mcp-community serveRun directly without installing permanently:
uvx eight-mcp-community serveIf Eight returns Cloudflare-style 403 responses with valid cookies, use the optional curl_cffi transport. It impersonates Chrome for the normal CLI/MCP path and does not require Playwright:
uvx --from 'eight-mcp-community[cloudflare]' eight-mcp-community serveIf you install with python -m pip install --user eight-mcp-community, the command may be placed under ~/.local/bin, which is not always on PATH. Either add that directory to PATH, use the absolute path, or run the module form:
python -m eight serve
~/.local/bin/eight-mcp-community serveMCP client configuration:
{
"mcpServers": {
"eight": {
"command": "uvx",
"args": ["eight-mcp-community", "serve"]
}
}
}Codex MCP examples:
# PATH-based
codex mcp add eight -- eight-mcp-community serve
# pip --user / absolute-path style
codex mcp add eight -- /Users/you/.local/bin/eight-mcp-community serve
# module form, useful when the command is not on PATH
codex mcp add eight -- python3 -m eight serve
# Cloudflare-resistant transport via uvx
codex mcp add eight -- uvx --from 'eight-mcp-community[cloudflare]' eight-mcp-community serveAfter package upgrades, optional dependency changes, authentication changes, or MCP configuration edits, restart Codex / your MCP client or otherwise restart the MCP server process. Already-running MCP servers keep using the old Python process.
Recommended post-install message for agents:
Eight MCP registration is installed. Authentication is intentionally simple:
1. Check current state: /Users/you/.local/bin/eight-mcp-community auth-status
2. If no cookie is configured, log in with Playwright. Recommended install for Eight login reliability: python -m pip install --user 'eight-mcp-community[browser,cloudflare]' && python -m playwright install chromium
3. If you already have a trusted Cookie header, save it directly: /Users/you/.local/bin/eight-mcp-community set-cookie '<COOKIE_HEADER>'
If a known-good cookie returns 403, use/install eight-mcp-community[cloudflare]. Restart Codex or the MCP client after package/auth/config changes.Local development MCP config:
{
"mcpServers": {
"eight": {
"command": "uv",
"args": [
"--directory",
"/path/to/eight-mcp-community",
"run",
"eight-mcp-community",
"serve"
]
}
}
}The authentication surface is intentionally small:
auth-status checks whether a Cookie header is configured and whether it can currently access Eight.
auth-login uses Playwright for an interactive browser login, captures 8card.net cookies, and saves them.
set-cookie saves a trusted Cookie header supplied from outside the MCP flow.
Unless you provide a Cookie header via set-cookie or EIGHT_COOKIE, logging in requires Playwright. For Eight, installing both browser and cloudflare extras is recommended because the final cookie verification may need Chrome-like HTTP transport:
python -m pip install --user 'eight-mcp-community[browser,cloudflare]'
python -m playwright install chromium
~/.local/bin/eight-mcp-community auth-loginThe MCP eight_auth_login tool runs the CLI login flow in a subprocess so Playwright does not collide with the MCP server's asyncio loop.
If Playwright's browser binary is missing, install it once on the same machine/user account:
python -m playwright install chromiumCreate or overwrite the config file from a trusted Cookie header:
~/.local/bin/eight-mcp-community set-cookie '<COOKIE_HEADER>'
~/.local/bin/eight-mcp-community auth-statusSupported credential lookup order:
EIGHT_COOKIE — externally supplied Cookie header
EIGHT_MCP_COMMUNITY_CONFIG — path to config JSON with a cookie field
Default config file: ~/.config/eight-mcp-community/config.json
If auth-login times out after the browser reached /myhome, the cookie was probably captured but the verification HTTP request failed. The timeout message includes the last non-secret diagnostic (reason, HTTP status, final URL, and Cloudflare-like signal). Use the [cloudflare] extra and restart the MCP client:
python -m pip install --user 'eight-mcp-community[cloudflare]'eight-mcp-community auth-status
eight-mcp-community auth-login
eight-mcp-community set-cookie 'Cookie header'
eight-mcp-community search '鈴木'
eight-mcp-community search '鈴木' --source all
eight-mcp-community fetch-person '<ID_FROM_SEARCH>'
eight-mcp-community serveAll command output is JSON except --help.
Authentication tools:
eight_auth_status — check whether auth is configured and whether the current Cookie can access Eight
eight_auth_login — open a Playwright browser login flow, capture cookies, and save them through eight_set_cookie
eight_set_cookie — store a trusted Cookie header in the local MCP config file
Search tools:
eight_search_person — search people and return minimal result fields plus fetchable ids. By default it searches only registered/exchanged cards. Set source: "all" to also search public Eight network results. Public network people are returned in network; public network company hits are returned separately in network_companies.
eight_fetch_person — fetch detailed fields for an id returned by eight_search_person. Registered-card ids can include contact fields such as email and phone numbers; public-network ids return public profile-style fields when available.
Search results are intentionally minimal and LLM-safe: id, source, name, company, department, title, updated date, confidence/source bucket, and when available matched_fields / match_excerpt so users can understand why a result matched. Raw HTML, raw JSON, cookies, tokens, email addresses, phone numbers, and bulk exports are not returned by search. Use eight_fetch_person only when detailed contact/profile fields are actually needed.
Do not use this project for bulk contact export or contact-list harvesting.
Do not commit cookies, config files, raw API dumps, screenshots, or credentials.
Treat registered business-card results as private context; cite public sources for public-facing reports.
Eight business-card data can be stale. Corroborate current affiliation/title with public sources when accuracy matters.
uv sync --dev
uv run ruff check .
uv run pytestManual MCP smoke test:
printf '%s\n' \
'{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"smoke-test","version":"0.0.0"}}}' \
'{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}' \
'{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' \
| timeout 5s uv run eight-mcp-community serveRun CLI browser login in a subprocess, capture Eight cookies, and save them.
| Name | Required | Description | Default |
|---|---|---|---|
| headless | No | ||
| timeoutSeconds | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses that the tool runs a subprocess (browser CLI), captures cookies, and saves them, but lacks details on error handling, side effects, or where cookies are saved. This is adequate but not thorough.
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?
A single, clear sentence with no extraneous information. It is front-loaded with the core action, though it could be structured with bullet points for 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?
Has an output schema so return values are not needed in description. However, for a tool that runs a subprocess, more context on interactivity, expected browser, and post-login state would improve completeness. It is functional but leaves gaps.
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 0%, and the description does not explain the parameters 'headless' and 'timeoutSeconds'. While names are somewhat self-explanatory, the description fails to compensate for the missing schema documentation.
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 it runs a CLI browser login in a subprocess, captures Eight cookies, and saves them. It uses a specific verb 'login' and resource 'auth', distinguishing it from siblings like eight_auth_status, eight_fetch_person, etc.
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?
No guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as whether an existing session is required, or when not to use it (e.g., if cookies are already present).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check whether Eight authentication is configured and currently usable.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It indicates a read-like operation but does not explicitly state it is non-destructive, nor describe error cases or output behavior. The output schema exists but description lacks details beyond the one-line summary.
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?
Single sentence, no wasted words. Front-loaded with the core action: 'Check whether Eight authentication is configured and currently usable.'
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 zero parameters and an existing output schema, the description is sufficient. It tells the tool's purpose clearly. Could mention return format or side effects, but output schema likely covers details.
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?
No parameters exist in the input schema, so baseline is 4. Description adds no parameter info as none are needed.
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 it checks whether Eight authentication is configured and usable, using specific verb 'Check' and resource 'authentication status'. It differentiates from siblings like eight_auth_login (login) and eight_fetch_person (fetching person data).
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 using this tool to verify auth status before using other tools, but does not explicitly state when not to use it or suggest alternatives. However, sibling tool names provide context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch detailed contact/profile fields for an id returned by eight_search_person.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It does not mention side effects (e.g., read-only), authentication requirements, error handling, or what happens for invalid ids. This is a significant gap for a fetch operation.
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 sentence that conveys essential information efficiently. It is appropriately sized for a simple tool, though it could be slightly more structured (e.g., separate usage hint). No waste.
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 has one parameter and an output schema, the description covers the core purpose and id source. However, it lacks behavioral context (e.g., authentication, id validity) and does not leverage the output schema to explain return values (though not required). Adequate but with clear gaps.
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 schema has 0% description coverage, but the description adds meaning by specifying the id parameter is 'returned by eight_search_person'. This provides context beyond the bare schema, though further details (e.g., id format) would improve it.
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 fetches detailed contact/profile fields for an id from eight_search_person. It uses a specific verb ('Fetch') and resource ('contact/profile fields'), and distinguishes from the sibling search tool by specifying the source of the id.
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 indicates the tool should be used with an id returned by eight_search_person, providing clear context. However, it does not give explicit when-not-to-use scenarios or alternatives beyond the implied dependency on the search tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search registered Eight cards by default; source='all' also includes public network.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | ||
| source | No | registered | |
| perPage | No | ||
| networkLimit | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry the full burden. It mentions the default source scope and the effect of source='all', but lacks details on pagination behavior (perPage, networkLimit), potential rate limits, or safety implications. The behavior is only partially disclosed.
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 very concise (two clauses), front-loading the key purpose. It efficiently conveys the default behavior and the optional source parameter. However, it could be slightly more verbose without losing conciseness to cover more parameters.
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 presence of an output schema (so return values don't need explanation), the description provides a basic understanding of the search scope. However, for a tool with 4 parameters, the missing explanations for query, perPage, and networkLimit leave gaps. It is adequate but incomplete.
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?
With 0% schema coverage, the description should explain all parameters. Only the 'source' parameter gets partial explanation (default vs all). The 'query' parameter is not described, and 'perPage' and 'networkLimit' are completely undocumented. The description adds minimal value beyond 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 clearly states the tool searches for person cards, with a default scope of registered cards and optional expansion to public network. The verb 'search' and resource 'person cards' are specific, and the sibling 'eight_fetch_person' suggests a distinction between searching and fetching, though not explicitly stated.
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?
No guidance is provided on when to use this tool versus alternatives like eight_fetch_person. The description does not mention prerequisites, use cases, or when not to use it, leaving the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Store a Cookie header in the local MCP config file.
| Name | Required | Description | Default |
|---|---|---|---|
| cookie | Yes | ||
| verify | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses persistence ('local MCP config file') but omits details like overwrite behavior, side effects, or security implications. The 'verify' parameter is not explained.
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?
Single sentence is concise but lacks structure. It earns its place by being short, but conveys minimal information.
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?
With a moderately complex input schema (2 params, optional boolean) and an output schema present, the description fails to explain return values, side effects, or how this tool fits into the auth workflow. Incomplete for safe agent use.
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 0%, and the description adds no parameter details. It only mentions 'Cookie header' loosely, leaving both 'cookie' and 'verify' parameters unexplained.
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 the action ('Store a Cookie header') and location ('local MCP config file'), distinguishing it from sibling tools like eight_auth_login or eight_fetch_person. However, 'Cookie header' is slightly ambiguous—could be more precise like 'a cookie value'.
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?
No guidance on when to use this tool vs alternatives (e.g., eight_auth_login). The description does not mention prerequisites, context, or user scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.2.0eight_auth_logineight_auth_statuseight_fetch_personeight_search_personeight_set_cookieScored across 5 tools
Each tool has a distinct purpose: authentication operations (login, status, cookie management) are separate from data retrieval (search, fetch). No overlap or ambiguity.
All tools follow the consistent pattern 'eight_verb_noun' (e.g., auth_login, fetch_person). No mixing of conventions or vague verbs.
5 tools is a compact but complete set for authentication and basic contact retrieval. Not bloated or insufficient.
Covers authentication and read operations (search, fetch) well, but lacks write operations like create/update/delete person. Minor gap for a contact management domain.
People and property search for Claude and ChatGPT. Phones, emails, addresses, relatives, properties.
Plain-English people search with verified work emails, email verification and LinkedIn lookup.
Search companies, enrich contacts, and reveal emails and phones from your AI agent.
Find verified B2B emails and phone numbers; search and enrich people and companies for prospecting.
