Website profiles · Technology insights · Alternatives

thecompaniesapi.com

Search and enrich millions companies, find similar businesses, and get notified about important events. Use our API and data to supercharge your product or marketing tools.

Paid content Multilingual
Visit website
Profile views 11 Outbound visits 3 Normal
The Companies API Full homepage screenshot

At a glance

Category
Development
Language
English
Paid-content signal
Paid contentObserved
Registered
2022
Hosting
CloudflareInferred
HTTPS certificate trusted
PassedObserved
Last updated

Website review

This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.

What is The Companies API?

The Companies API is a company-data API: you send it an identifier such as a domain name, email address or social network URL, and it returns a structured company profile. According to its own page, a single call can return 300+ data points, covering basics like legal name, industries, employee count and founding year, plus domain details, social profiles, logos, financial signals such as revenue band and stock ticker, and relationship data such as acquisitions and subsidiaries.

Who it is for

  • Product teams adding company lookup, auto-fill or "similar companies" features.
  • Sales and marketing tools that need to enrich leads or segment accounts by industry, size or location.
  • Developers who want company data behind a normal API rather than maintaining their own database.

What makes it distinctive

The page emphasises breadth in one response and real-time processing, with a large company database and high request volume cited as evidence of scale. It also lists enrichment by domain, email or social URL, similar-business search, and event notifications, so it can support monitoring use cases and not just one-off lookups.

Trade-offs to weigh

A broad schema means many fields, some of which will be irrelevant or empty for smaller companies, so plan for missing values. Banded fields (for example, employee or revenue ranges) are easier to filter on but less precise than exact figures. Enrichment quality also varies by region and company size, so test against your own list before committing.

Practical next step

Pick 20–50 companies you already know well, run them through the free credit allowance, and check accuracy on the fields your feature actually depends on. Compare that against alternatives such as Clearbit or Crunchbase if you need different coverage or bundled tools.

How can I enrich a company profile from a domain name using the API?

Send the domain to the enrichment endpoint and read the returned company profile. The Companies API is built around exactly that flow: its page headline is "Turn a domain name into a company profile," and it describes enriching companies in a single API call with 300+ data points. The sample response on the page shows a domain block (domain, alias, registrar, status) alongside about, finances, locations, socials and analytics blocks, so one call can populate a full profile rather than just a name and logo.

What the enrichment actually returns

In the documented response shape, a domain lookup can give you:

  • Identity: legal and display name, name alternatives, business type, year founded and founding place.
  • Classification: industry and industry list, languages.
  • Size and money: employee count both as a band (over-10k) and an exact figure, revenue band, stock exchange and ticker.
  • Web presence: monthly visitors band, domain registrar and status, social profile links.
  • Descriptions and assets: primary description, tagline, mission-style website text, logo and cover images.
  • Relationships: acquisitions and subsidiaries.

The page also states you can enrich by domain, email or social network URL, and separately search companies, find similar businesses and subscribe to event notifications. Those are different endpoints from a straight domain-to-profile lookup, so decide which one your feature needs before you build.

A concrete integration path

  1. Collect the domain at the point where you already have it — signup form, CRM record, or a user pasting a URL. Normalize it first (strip https://, www., paths and query strings) so www.microsoft.com and microsoft.com resolve to the same record.
  2. Call the enrichment endpoint with that domain and parse the JSON into your own schema. Don't bind your database columns directly to their field names; map them, because bands like over-10k and exact values like 221000 are different types and you may want to store both.
  3. Cache the result against the domain with a timestamp. Company data changes — headcount, revenue band, domain status — so treat the profile as a snapshot, not a permanent fact.
  4. Handle the miss case explicitly. Domains that are parked, newly registered, or not in the database will return thin or empty blocks. Your UI should degrade to "we couldn't find details for this domain" rather than render blank fields.

Choosing between enrichment and search

Need Use
You already have a domain, email or social URL Enrichment lookup
You have criteria (industry, size, region) but no company Company search
You have one company and want lookalikes Similar-business lookup
You want to react when something changes Event notifications

The trade-off is straightforward: enrichment is precise but only works when you already hold an identifier. Search is broader but returns candidates you must filter and deduplicate yourself.

Practical notes

The page advertises 500 free credits with no credit card required and a 20-minute demo booking, and its meta block in the sample response includes cost, credits and freeRequest fields — so check the credit cost per call before wiring enrichment into a high-traffic path like page views. If every profile view triggers a lookup, credit consumption scales with traffic, not with customers. Cache aggressively and refresh on a schedule instead.

For a typical use case — a B2B signup flow that wants to pre-fill company name, industry, headcount band and logo from the work email domain — a single cached enrichment call per new account is enough, and the assets.logoSquare and descriptions.primary fields cover most of the visible UI. Accounts in the same domain should share one cached record.

As a next step, make one test call with a domain you know well and compare the returned about, finances and locations blocks against public information. That tells you quickly which fields are reliable enough for your product and which you should show as "estimated" or hide.

What pricing plans and free credit options are available?

The site advertises a free starting allowance rather than a published price list in the material provided: new users can get 500 free credits with no credit card required, and a 20-minute demo can be booked. Beyond that, the available information points to a separate pricing page, so the exact tiers, credit costs per request, and any subscription terms would need to be checked there.

What is confirmed

  • 500 free credits on signup.
  • No credit card required to start.
  • A demo booking option for a walkthrough.
  • A dedicated pricing page exists at The Companies API (Pricing).

What is not confirmed

  • The names, limits, or monthly cost of paid plans.
  • How many credits a single enrichment call consumes.
  • Whether credits expire, roll over, or reset monthly.
  • Any enterprise or custom-quote tier.

Practical decision criterion

If you are evaluating this for a product feature, the free credits are best treated as a proof-of-concept budget. Start with a small batch of domains you already know well, measure how many credits each enrichment consumes, and compare that against your expected monthly call volume. That tells you more about real cost than any headline plan name.

For a concrete scenario: a small SaaS team enriching signup domains might exhaust 500 credits quickly if each lookup returns a full company profile. A team testing a single integration path, by contrast, can stretch the allowance across several days of development. The right next step is to open the pricing page and confirm the credit-to-request ratio before committing to a paid tier.

How do I find companies similar to a given business?

Use the "find similar businesses" capability: you give the API a reference company (typically its domain), and it returns other companies judged similar to it. On The Companies API, this sits alongside search and enrichment in the same product, and the response schema shows a similarity field under meta, which is where a match score for that kind of query would appear.

H3 How a similarity lookup usually works

  1. Pick a seed: a domain, company name, or profile you already have.
  2. Query the API for similar companies.
  3. Read the returned profiles and any similarity score.
  4. Filter and rank locally against your own criteria.

H3 What to use as the seed

  • Domain is the cleanest input, since the same company can appear under different names.
  • Email or social URL also work for enrichment, so you can build a seed from a CRM record rather than a website.
  • Avoid using a bare name if it is ambiguous; you will pull the wrong company.

H3 A concrete scenario A sales tool wants "companies like this prospect" for a lookalike list. You store the prospect's domain, call the similarity endpoint, then enrich each returned company to get industry, employee count, headquarters and revenue band. Rank by similarity, then filter to your target size and region. Because enrichment returns fields such as industries, totalEmployees, locations.headquarters and finances.revenue, you can do that filtering on the API response instead of scraping sites yourself.

H3 Trade-offs to expect

Approach Strength Weakness
API similarity lookup Consistent, repeatable, scriptable You depend on the vendor's notion of "similar"
Manual research You control the criteria Slow, hard to scale
Keyword or industry search Transparent logic Misses companies that look different on paper

The main risk is that "similar" is the vendor's model, not yours. Treat the score as a ranking hint and re-rank with your own fields. Similarity also tends to cluster around size and industry, so niche or unusual businesses may return weak matches.

Next step: run one seed domain through the similarity call and one through enrichment, then compare whether the returned fields actually support the filter you need before wiring it into a product.

What types of events can I get notified about for companies?

The Companies API mentions event notifications as a capability, but the page evidence supplied here does not list specific event types. The visible material focuses on enrichment (turning a domain into a company profile with 300+ data points) and on "get notified about important events" only at a general level.

What the page does tell you

  • The product is built around company enrichment by domain, email or social network URL, plus similar-company search.
  • Notifications are positioned as a monitoring layer on top of that company data, not as a separate product.
  • Concrete event categories, delivery channels (webhook, email, in-app) and filters are not shown in the evidence, so treat any list of event types as unconfirmed until you check the product's own documentation.

How to find out

Open the API documentation or the dashboard's notification settings on The Companies API and look for a webhook or subscription section. Ask three things:

  1. Which triggers exist (for example funding, leadership change, hiring, domain or website status change).
  2. How you scope them (a watchlist of domains, an industry, a saved search).
  3. How they arrive and how often (real-time webhook vs. digest).

A practical scenario

Say you run a CRM for B2B sales. You enrich each new lead's domain, then subscribe to events for those domains so a rep sees a signal before a call. If the event list is narrow, you would pair it with scheduled re-enrichment and diff the fields yourself; if it is broad, you can rely on the feed and spend your engineering time elsewhere.

Decision criterion

Choose notifications over polling only if the events you care about are covered and delivered promptly enough for your workflow. Otherwise, schedule periodic re-enrichment and compare stored profiles — that approach works with any enrichment source and needs no event support at all.

How can I integrate The Companies API into my product or marketing tool?

You integrate The Companies API by sending it a company identifier your product already has — typically a domain name, email address, or social network URL — and getting back a structured company profile. The page's own example shows a domain turning into a JSON object with fields like name, industries, employee counts, revenue band, headquarters, social links, and logos. So the integration question is really: which of your existing user actions should trigger an enrichment call, and what do you do with the response?

Practical integration patterns

  • Form autofill: when a user types their work email or company website during signup, call the API and prefill company name, size, industry, and logo. This cuts friction and improves data quality.
  • Lead enrichment in a CRM or marketing tool: enrich new leads automatically, then route or score them by industry, employee band, or revenue band.
  • Account-based personalization: use industry, description, and tagline fields to tailor landing pages, onboarding copy, or outbound messaging.
  • Similar-company and event features: the product description mentions finding similar businesses and getting notified about important events, which suits prospecting tools and competitive monitoring.
  • Internal data hygiene: bulk-enrich or de-duplicate a company database by domain.

Language and scale

The page highlights building features "in your favorite programming language," and reports 40M+ API requests served in 30 days, 50M+ companies, and 300K+ companies scanned in the last 24 hours. For a typical product team that means the API is designed for steady production traffic rather than occasional lookups. A simple architecture is: enrichment call on the server side, cache the result against the domain, and refresh only when you need fresher fields.

What to check before committing

Consideration Why it matters
Match key Domain, email, and social URL each behave differently; email may map to a person rather than a company
Field coverage Confirm the 300+ data points actually include the fields your feature depends on
Freshness Decide which fields need real-time accuracy versus cached values
Cost model Credits are the unit mentioned on the page; review The Companies API pricing against your expected call volume
Fallbacks Plan for missing or ambiguous matches so your UI degrades gracefully

A concrete first step

Take one high-value screen in your product — signup, lead capture, or an account page — and enrich a single field there, such as company logo or employee band. Start with the free credits and a demo to validate match quality on your own data before rolling enrichment into every workflow.

Related questions

More questions →
What Is OpenAPI-Generated API Documentation and How Does It Work?

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

Dimension OpenAPI-generated Hand-written
Source of truth The spec file The prose
Consistency with the API High, if the spec is accurate Drifts as the API changes
Effort per endpoint Low after setup Repeated for every endpoint
Narrative and tutorials Weak; needs separate pages Strong
Code samples Generated per language from schemas Written and maintained manually
Customization Bounded by the tool's templates Unlimited
Failure mode Accurate spec, poor docs, or stale spec Beautiful docs that describe an API that no longer exists

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.

Website Overview

Several search or sharing settings need attention. Together they may make snippets, preview images or preferred URLs less consistent across platforms.

Domain and Registration

Transfer-protection status is present, helping reduce the risk of unauthorized domain transfers. The domain has about 4 years of registration history; its current configuration provides more context than age alone. The registrar is Gandi SAS, a widely used domain service provider. The domain uses the common .com extension, which is not an independent safety signal.

DNS and Email

Nameservers are provided by Cloudflare, indicating managed DNS hosting. MX records point to the Google Workspace email service. No CNAME was found; the observed records resolve directly to addresses. SPF and DMARC are configured. DKIM status is unknown. TXT records include verification markers for Google. Such markers may also remain after a service stops being used.

TLS and Certificates

The public key uses EC with 256 bits. The server supplied a complete certificate chain. No organization name is present in the certificate; the available fields are consistent with domain validation. The certificate was issued within the Google Trust Services cloud or CDN ecosystem. The certificate's total validity is about 90 days, consistent with a short renewal cycle.

HTTP and Browser Security

X-Powered-By exposes backend information: Nuxt. The checked browser-security headers were not detected, leaving fewer explicit browser-side safeguards. The cf-ray response header indicates a CDN or caching proxy in the delivery path. No obvious internal addresses or debug information were found in the headers. The Server header identifies cloudflare without an exact version.

Technology Stack Analysis

The public page identifies Nuxt, Tailwind CSS, Cloudflare without precise versions, leaving fewer clues for version-specific scanning.

Search and Social Sharing

The meta description has 172 characters and may be shortened in search results. Open Graph is partially configured; og:title, og:description is missing. Twitter Card metadata is configured. The page declares 4 language or regional alternatives using hreflang. The title has 48 characters, within a common display range.

Hosting and Email

DNSCloudflare
HostingCloudflare
EmailGoogle Workspace
Approximate IP geolocation (inferred; a CDN or proxy may differ from the origin server) Location unknown Inferred 104.21.71.222

Registration details

RDAP / WHOIS

RegistrarGandi SAS
Registered2022-07-28
Expires2028-07-28
Domain statusclient transfer prohibited
Nameserversdesi.ns.cloudflare.com、nash.ns.cloudflare.com
DNSSECunsigned

DNS records

DNS

TypeNameValueTTLPriority
Awww.thecompaniesapi.com104.21.71.222300—
Awww.thecompaniesapi.com172.67.149.181300—
AAAAwww.thecompaniesapi.com2606:4700:3035::6815:47de300—
AAAAwww.thecompaniesapi.com2606:4700:3035::ac43:95b5300—
MXthecompaniesapi.comaspmx.l.google.com36001
MXthecompaniesapi.comalt1.aspmx.l.google.com36005
MXthecompaniesapi.comalt2.aspmx.l.google.com36005
MXthecompaniesapi.comalt3.aspmx.l.google.com360010
MXthecompaniesapi.comalt4.aspmx.l.google.com360010
NSthecompaniesapi.comdesi.ns.cloudflare.com86400—
NSthecompaniesapi.comnash.ns.cloudflare.com86400—
TXTthecompaniesapi.comgoogle-site-verification=ABCzYGRig9XBU0coos2wYOk1JuPexAr9T1UXyabRnE8300—
TXTthecompaniesapi.comgoogle-site-verification=N5xpgyE8e4I12mC5o9_OW51G66O9-UwAhNeCls8KQVc300—
TXTthecompaniesapi.comv=spf1 include:_spf.google.com -all300—
DMARC_dmarc.thecompaniesapi.comv=DMARC1; p=none;300—

TLS and certificates

TLS / SSL

AssessmentNormal configuration
Supported protocolsTLSv1.2、TLSv1.3
Negotiated protocolTLSv1.3
Certificate subjectthecompaniesapi.com
IssuerGoogle Trust Services
Valid until2026-12-10T10:22 · Remaining when checked: 68 days
Verification detailsCertificate trust: Passed · Hostname match: Passed

HTTP response headers

HTTP

HeaderValue
content-typetext/html;charset=utf-8
servercloudflare
set-cookieRedacted

Identified technologies

NuxtTailwind CSSCloudflare

Pages, Search and Sharing

Meta descriptionSearch and enrich millions companies, find similar businesses, and get notified about important events. Use our API and data to supercharge your product or marketing tools.
Canonical URLhttps://www.thecompaniesapi.com
LanguageEnglish (default) · Multilingual
Twitter Cardsummary_large_image
All bots 0 allowed · 0 disallowed

User reviews (0)

  • No reviews yet.