crustdata.com

Crustdata is a real-time B2B data provider that covers people and companies, sourced by indexing web pages and resolving them into a single live graph. According to its site, the graph contains 1B+ people and 60M+ companies (one page section also cites "200M+ companies," so treat the company count as an approximate, potentially broader figure). The data is exposed through a REST API or MCP, and is intended for sales, recruiting, and investment workflows run by AI agents.

What Crustdata covers

The company count discrepancy is worth noting if you're sizing the dataset against a specific target market: the homepage headline says 60M+, while a graphic on the same page says 200M+. The site does not explain the difference, so verify the current figure with Crustdata before relying on either number for planning.

How the data is sourced

Crustdata states that it "indexes every web page on the internet and parses it into one live graph of people and companies." In practice, that means the source is public web content, not a purchased static database. The value comes from two steps:

1. Indexing — collecting web pages at scale.
2. Resolution — parsing those pages and merging the results into a unified graph, so a person or company appears as one entity rather than scattered fragments.

Because the graph is described as live, records reflect recent changes rather than a periodic snapshot. The site illustrates this with an example: a person who "left 6 days ago after 3 years" and is "now weighing offers," alongside recent activity such as open-source commits. That level of recency is the main differentiator Crustdata claims over static data vendors.

What you can do with it

The site names three operations:

• Search — find people or companies matching criteria.
• Enrich — add graph data to records you already have.
• Watch — monitor entities for changes over time.

These are available via API or MCP, which is what makes the data usable inside AI agents rather than only in a dashboard.

How to evaluate fit

• If you need recent job changes or activity signals, the live-graph approach is the relevant feature to test — ask for a sample on your target segment and check how fresh the timestamps are.
• If you need a fixed, auditable snapshot for compliance or historical analysis, a live graph may not match that requirement; confirm whether historical states are retained.
• If company count matters for coverage, resolve the 60M vs. 200M question directly with the vendor.
• If you're building on agents, confirm API and MCP access terms, rate limits, and pricing at crustdata.com/pricing, since the site does not publish those details on the pages reviewed here.

The site includes customer comments from Transpose Platform, The Firm, and CoffeeSpace praising data depth and match quality, but these are vendor-published testimonials rather than independent evaluations — treat them as directional, and validate with your own sample data.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

Crustdata connects to AI agents through two access paths: a REST API and an MCP (Model Context Protocol) server. Both expose the same underlying data layer — a live graph of people and companies that Crustdata builds by indexing and parsing web pages. If your agent needs to search, enrich, or watch B2B people and company records, you wire it to one of these two interfaces rather than to a static database export.

The two integration paths

The distinction matters for how much plumbing you write. With the REST API, your agent (or the code around it) decides when to call which endpoint and how to shape the response. With MCP, the agent's host discovers Crustdata's capabilities as tools, so the model can select and invoke them without you hand-wiring each call.

What the agent actually gets

Crustdata describes its graph as covering 1B+ people and 200M+ companies, assembled by indexing every web page it can reach and resolving those pages into a single live graph. Three verbs describe what an agent can do against it:

• Search — find people or companies matching criteria.
• Enrich — attach detail to a record the agent already has.
• Watch — track changes over time.

The company frames the outcome in workflow terms: sourcing, selling, and scouting run end to end by agents, and the quality of those flows depends on the data handed to them. Its own illustration makes the gap concrete — a generic agent knows only that "Maya Chen is a staff-level engineer with a strong background," while the same agent with Crustdata data sees her title, prior employer, tenure, departure timing, and current activity. That difference is the product's pitch: the agent's reasoning is only as good as the record it reasons over.

Where this fits in practice

Crustdata positions itself as "the data layer behind modern teams and platforms in sales, recruiting and investing," and the homepage leads with a recruiting example ("Turn your Agent into a world-class recruiter"). So the typical integration is an agent that already has a job to do — source candidates, build a target account list, screen a deal — and needs a live people-and-company feed to do it.

Two practical notes before you commit:

• Verify current coverage and limits against the live docs. The 1B people / 200M companies figures come from the vendor's own site and describe the graph, not your plan's quota. Rate limits, field-level coverage, and freshness per data type are the details that decide whether a given workflow works.
• Check pricing directly. Crustdata links to a pricing page, but the available material doesn't state tiers, free access, or login requirements. Don't assume a free tier or open access — confirm on that page before designing around it.

Choosing between API and MCP

Pick the REST API if you're building the agent loop yourself, need to control call timing and payload shape, or are running enrichment as a backend job rather than inside a conversational agent. Pick MCP if your agent runs in an MCP-compatible host and you'd rather let the model discover and invoke Crustdata's tools than write and maintain the integration glue.

If you're unsure, start with whichever your existing agent stack already supports — both reach the same graph, so the choice is about integration ergonomics, not data access.

Crustdata is a real-time B2B data provider that supplies people and company data to AI agents and software platforms through an API or MCP. It indexes web pages and resolves them into a single live graph of people and companies — the site states 1B+ people and 60M+ companies (a graph visualization on the page shows 200M+ companies). It is positioned as the data layer for sales, recruiting, and investment workflows, so it is most relevant if you are building or operating an agent that needs to source, enrich, or monitor people and companies.

What Crustdata actually provides

The core product is a data layer, not an end-user app. According to the site, Crustdata:

• Indexes every web page on the internet and parses it into one live graph of people and companies.
• Exposes that graph through a REST API or MCP (Model Context Protocol), so agents and applications can query it directly.
• Covers 1B+ people and 60M+ companies (the page's graph visual labels 200M+ companies).
• Supports three primary operations shown on the page: Search, Enrich, Watch.

The "Watch" capability matters for agent workflows: the page's example shows a person record updating when someone files a new C-corp or changes jobs, which is the kind of freshness signal that sourcing and recruiting agents depend on.

How it is used

Crustdata is described as "the data layer behind modern teams and platforms in sales, recruiting and investing." In practice that means you feed its data into your own agent or product rather than working inside a Crustdata UI. The page frames the value this way: agents now run sourcing, selling, and scouting flows end to end, and the outcome depends on the data you hand them.

A concrete illustration from the page contrasts two levels of data quality:

The point is that structured, current, role- and event-level detail is what lets an agent act, rather than produce a vague summary.

Who it is for

• Sales teams and platforms building prospecting or enrichment agents.
• Recruiting teams — the page's headline example is turning an agent into a "world-class recruiter," with one customer quoted saying Crustdata surfaces "50 to 60 people that are great fits."
• Investing workflows that need company and people data.
• Developers who want B2B data via API or MCP rather than a manual research tool.

Customer quotes on the page come from Transpose Platform, The Firm, and CoffeeSpace, and mention comparisons with Affinity and Clay.

What to check before committing

• Pricing and access terms are not specified in the material available here. There is a pricing page at crustdata.com/pricing, but no rates, free tier, or login requirements are stated, so verify those directly before assuming cost or open access.
• Integration path: confirm whether your stack fits REST API or MCP, since those are the two stated access methods.
• Data freshness expectations: the "Watch" and live-graph framing implies updates, but the update frequency and coverage guarantees are not detailed in the available material — ask for specifics if your workflow depends on real-time changes.

If you need B2B people and company data piped into an AI agent for sourcing, enrichment, or monitoring, Crustdata is built for exactly that. Start by checking the pricing page and requesting a demo to confirm coverage, latency, and terms for your use case.

Crustdata does not publish self-serve pricing on its homepage. To get started, you either request a demo through the site or go directly to its pricing page at https://crustdata.com/pricing. Both paths are aimed at teams evaluating a paid B2B data contract rather than individual developers signing up for a free tier. If you need a concrete number before committing, the demo request is the intended first step, since the site routes buyers there instead of offering instant checkout.

What Crustdata provides

Crustdata is a real-time B2B data provider built for AI agents. According to its site, it indexes web pages and resolves them into a single live graph of people and companies, exposed through an API or MCP (Model Context Protocol).

The scale it advertises:

The stated use cases are sales, recruiting, and investment workflows — sourcing candidates, prospecting accounts, and scouting companies. The site positions the data layer as the deciding factor in how well an agent performs those flows.

How to get access

There is no documented self-serve signup flow in the available material. The two entry points the site presents are:

1. Get a Demo — the primary call to action on the homepage. This connects you with the sales team, who can scope your use case and quote pricing.
2. Pricing page — https://crustdata.com/pricing, linked in the site navigation, where plan details are listed.

If you are building an agent and want to test the data before a contract, ask about evaluation access during the demo rather than assuming a free tier exists. The site does not state that API or MCP access is free or login-free.

What to prepare before the demo

Because pricing is quote-based, the conversation moves faster if you arrive with specifics. Useful things to have ready:

• Volume estimate — how many people or company records you expect to enrich or search per month.
• Access method — whether you need REST API, MCP, or both, and which agent framework you are wiring it into.
• Workflow — recruiting, sales prospecting, or investing, since the site markets these separately and the data fields you need will differ.
• Freshness requirements — the product emphasizes real-time data (for example, flagging a person who changed jobs days ago), so state how current your results must be.

Reading the pricing page

When you open https://crustdata.com/pricing, look for whether plans are tiered by record volume, by seat, or by API call. The available site data does not specify the pricing model, payment platforms, or whether a free tier exists — so treat anything not shown on that page as something to confirm with sales. If the page lists only "contact us," that confirms the deal is negotiated per customer.

A realistic first step

If you are comparing Crustdata against alternatives like Affinity or Clay, the demo is where you can test the depth claim directly. One customer quote on the site says Crustdata surfaced "50 to 60 people that are great fits" with a quality jump over prior tools, and another mentions switching after trying Affinity and Clay. Use the demo to run your own query — for example, ask it to return staff-level engineers who recently changed roles — and judge whether the freshness and depth match what your agent needs before you discuss contract terms.