Brand Logo Lookup API — Domain to Logo

Pay per logo. Fetch a company's logo from any domain — a drop-in Clearbit Logo alternative for enriching your CRM, lead lists, and product UIs.

Feed one domain or ten thousand and get back, for each, a working logo URL plus the metadata you need to use it — the source it came from, its content type and size, and whether the lookup succeeded. It is a keyless, code-friendly logo endpoint that tries several public logo sources in order and returns the first that resolves to a real image.

What this is, in one paragraph

Every brand has a logo somewhere public — a favicon, a logo service, an og:image — but stitching those sources together reliably is fiddly. This actor does it for you: for each domain it tries a chain of public logo candidates in quality order (a logo service, Google's favicon service, DuckDuckGo's icon service, the site's own /favicon.ico, and — only as a last resort — the site's og:image), checks that each candidate actually returns an image, and delivers the first hit with its source and size. Real logo and favicon sources are preferred over og:image so you get a brand mark, not a marketing banner. No API key, no personal data.

Who buys this and for what job

• Sales and RevOps teams enriching CRM records and lead lists with brand logos at scale.
• Product and design teams who need logos for company directories, dashboards, or autocomplete UIs.
• Data teams building company reference tables who want a logo URL keyed by domain.
• Builders and agents who need a keyless Clearbit-Logo replacement they can call from code.

Pricing

Event	Free plan	Bronze	Silver	Gold / Platinum / Diamond
logo-returned	$0.02	$0.018	$0.016	$0.0134

One logo-returned per domain processed — about 50 logos per dollar at the base tier. Delivered before charged; a domain that yields no logo still returns a record (with success: false) and counts as one processed lookup, exactly as a logo API would.

Input

Field	Type	Default	Description
domains	array	(required)	One or more company domains (e.g. stripe.com). URLs are accepted and normalised.
domain	string	—	A single domain (alias for domains).
includeOgImage	boolean	true	Also try the site's og:image as a last-resort candidate.
sizePreference	integer	128	Preferred logo size in px (16/32/64/128/256).

Output

One JSON object per domain. Real example:

{
  "record_id": "stripe.com",
  "domain": "stripe.com",
  "logo_url": "https://www.google.com/s2/favicons?domain=stripe.com&sz=128",
  "source": "google_favicon",
  "content_type": "image/png",
  "size_bytes": 580,
  "size_hint": "tiny",
  "candidates_tried": 2,
  "success": true,
  "error": null,
  "observed_at": "2026-08-25T00:00:00Z"
}

An unbilled RUN_RECEIPT records how many logos were delivered and whether charged equals delivered.

Field reference

Each record carries record_id and domain (the normalised domain), logo_url (a working URL to the logo), source (which candidate resolved — clearbit, google_favicon, duckduckgo_icon, favicon_ico, or og_image), content_type, size_bytes and a coarse size_hint, candidates_tried, success, and error (null on success). Provenance travels on every record: source_url, licence, attribution, disclaimer, and observed_at.

How a run works

For each domain the actor normalises it (stripping scheme, www, and any path), then walks the candidate chain in quality order. Each candidate is fetched and verified to be a real image — by content type and, as a backstop, by image magic bytes — so a placeholder HTML page never gets mistaken for a logo. The first candidate that resolves is returned with its source and size; if none resolve, the record is delivered with success: false so your pipeline sees every input accounted for. Each domain is billed once as a logo-returned event, whether or not a logo was found, matching how a logo API meters a lookup.

Working with the data

The logo_url is a direct, hotlinkable URL you can drop straight into a CRM field, a directory row, or an <img> tag. source and size_bytes let you prefer higher-quality logos where it matters — filter to clearbit/favicon_ico hits, or set a larger sizePreference — and fall back to the favicon services for coverage. Because the record is keyed by domain, it joins cleanly into any company table you maintain. Feed a whole domain list and get a complete logo column back in one run.

Honest limitations

• Public sources. Logos come from public logo/favicon services and each site's own public assets; availability and quality vary by domain.
• Trademarks. A logo is the trademark of its owner and is returned for identification/enrichment use — respect the owner's mark and any applicable outreach/privacy law.
• og:image is a fallback. When a real logo source is unavailable and includeOgImage is on, the site's share image may be returned; it can be a banner rather than a mark.
• No person data. Only a logo URL and its metadata are returned; no personal data is collected or emitted.

Use with AI agents

Point Claude, an OpenAI Agents SDK tool, an n8n or Make flow, or any MCP-aware client at this actor and hand it a list of domains. Because the output is flat JSON keyed by domain with a direct logo_url, an agent can enrich a lead list with logos in a single call and use success to route the misses to a human. A typical prompt: fetch logos for my list of company domains and flag any that failed.

Why the candidate chain matters

Most single-source logo endpoints fail silently: when the one service they wrap has no record of a domain, you get a broken image or a 404, and your pipeline has no way to tell a genuine miss from a transient outage. This actor treats logo lookup as a coverage problem rather than a single-endpoint call. It walks several independent public sources in quality order and returns the first that actually resolves to bytes that are an image — verified by content type and, as a backstop, by image magic bytes — so a soft-404 HTML page or a "sign in" interstitial can never be mistaken for a logo. The candidates_tried count on every record tells you how deep the chain had to go, which is a useful signal in itself: a domain answered on the first candidate is high-confidence, while one that only resolved on the final fallback deserves a human glance. Because each source has different strengths — some cover long-tail domains better, some return crisper marks, some are faster — chaining them gives materially higher coverage than any one of them alone, and the per-record source field keeps the whole thing auditable so you always know where a given logo came from.

Running at scale

Feed the actor a single domain to test, or a list of thousands to backfill a whole company table in one pass. Every input produces exactly one output record and exactly one logo-returned charge, whether or not a logo was found, so your cost is perfectly predictable: number of domains in equals number of records out equals number of events billed. The unbilled RUN_RECEIPT in the run's key-value store restates that reconciliation — logos delivered versus logos charged — so you can assert charged == delivered in your own automation and alert if they ever diverge. There are no hidden per-source charges, no charge for retries inside the candidate chain, and no charge for the run itself beyond the per-logo events. Set sizePreference once for the whole batch to bias every lookup toward the resolution your UI needs.

Differentiation

A domain-to-logo API, a drop-in Clearbit-Logo alternative that prefers real logo/favicon sources over marketing images and returns clean per-domain JSON. Keyless, pay-per-logo, callable from code or an AI agent.

---

Brand logos are fetched from public logo/favicon sources and each site's own public homepage assets. Logos are the trademarks of their respective owners; returned for identification/enrichment, not ownership of the mark. No personal data of any kind.