# Brand Logo Lookup API — Domain to Logo (`nexgensignal/brand-logo-lookup-api`) Actor

Domain-to-logo API: feed one domain or thousands and get a working logo URL plus source, content-type and size for each. Keyless, pay per logo, a drop-in Clearbit-Logo alternative for CRM and lead-list enrichment. Delivered before charged; misses return success:false.

- **URL**: https://apify.com/nexgensignal/brand-logo-lookup-api.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.40 / 1,000 logo returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 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:

```json
{
  "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.*

# Actor input Schema

## `domains` (type: `array`):

One or more company domains (e.g. stripe.com). URLs are accepted and normalised.

## `domain` (type: `string`):

A single domain (alias for domains).

## `includeOgImage` (type: `boolean`):

Also try the site's og:image as a logo candidate.

## `sizePreference` (type: `integer`):

Preferred logo size (16/32/64/128/256).

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "shopify.com"
  ],
  "includeOgImage": true,
  "sizePreference": 128
}
```

# Actor output Schema

## `results` (type: `string`):

Delivered records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "stripe.com",
        "shopify.com"
    ],
    "sizePreference": 128
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/brand-logo-lookup-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "domains": [
        "stripe.com",
        "shopify.com",
    ],
    "sizePreference": 128,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/brand-logo-lookup-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "stripe.com",
    "shopify.com"
  ],
  "sizePreference": 128
}' |
apify call nexgensignal/brand-logo-lookup-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/brand-logo-lookup-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/fZsEYFgc8aDBBdrSH/builds/9pW09cn5FhQLjPwAG/openapi.json