# Logo Finder: Company Logo API & Favicon by Domain — Logolark (`cybermax/logo-finder`) Actor

Logo finder and company logo API: give domains, URLs or work emails, get each company's own logo and square icon, verified by download (SVG/PNG/ICO, real size, transparency), its brand colour and a hosted copy. Clearbit Logo API alternative. $2 per 1,000 logos found; misses free.

- **URL**: https://apify.com/cybermax/logo-finder.md
- **Developed by:** [CyberMax](https://apify.com/cybermax) (community)
- **Categories:** Lead generation, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 logo resolveds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Logolark: Company Logo API & Favicon Finder by Domain

**Company logo API: domain in, logo out.** Give Logolark company domains, website URLs or work emails
and get back each company's **own best logo** and **best square icon**, taken from the company's website
and **verified by downloading them**: the real format (SVG, PNG, ICO, WebP, JPEG), real pixel size, transparency,
the **brand colour**, and a **hosted copy** with a stable link. A drop-in replacement for the retired
**Clearbit Logo API** (`logo.clearbit.com`), for CRMs, lead lists, dashboards, directories and AI agents.

**$0.002 per domain with a logo found. Misses are free.** No start fee, no subscription, no API key to manage
beyond your Apify token.

### Why Logolark

- **The company's own logo, not a guess.** Logolark reads everything a site publishes about its brand:
  the schema.org `Organization` logo, `og:logo`, the logo image or inline SVG in the site header, `<link rel="icon">`
  and `apple-touch-icon` tags, the web app manifest, and `/favicon.ico`. Customer and partner logo walls
  ("trusted by…") are skipped.
- **Verified, not declared.** Every candidate is downloaded and measured from its bytes. HTML error pages served
  as `logo.png`, 1×1 tracking pixels and broken links are rejected, and `sizes="512x512"` that is really 32 px
  is reported as 32 px.
- **Two answers, because you need two.** `logo` is the brand mark for display (wordmarks, often SVG);
  `icon` is the best **square** icon for avatars, tables and app tiles (512 px manifest icons, 180 px Apple icons,
  SVG favicons). Sites with only a favicon return it for both, with `logoIsIcon: true`.
- **Inline SVG logos included.** Many modern sites (Stripe, Basecamp, Figma, GitHub) draw their logo as inline SVG
  with no file URL. Logolark extracts it as a standalone `.svg` and hosts it for you.
- **Brand colour** from the actual pixels (PNG, ICO) or fills (SVG), plus the site's `theme-color`.
- **Emails work.** `jane@figma.com` resolves `figma.com`, so you can enrich a CRM export directly.
- **Fast and light.** Plain HTTP, no browser: 40 domains in 12 seconds on 1 GB. Slow sites get one automatic retry.

### Example

Input:

```json
{ "domains": ["stripe.com", "https://www.shopify.com", "jane@figma.com"] }
```

**First try:** this prefilled input runs in about 5 s and costs at most $0.006 (3 domains × $0.002).

Real results from test runs on the Apify platform, 23 Sep 2026 (10 inputs in 7 s; 5 inputs in 4.6 s):

| Input | Logo | Icon | Brand colour |
|---|---|---|---|
| stripe.com | inline SVG wordmark 60×25 | SVG favicon 512 | `#533afd` |
| https://www.shopify.com | schema.org SVG 304×87 | Apple icon (WebP) 72 | `#95bf46` |
| jane@figma.com | inline SVG 32×48 | manifest PNG 512 | `#00b6ff` |
| mozilla.org | header SVG 984×235 | Apple icon PNG 180 | `#00d230` |
| hubspot.com | header SVG 1256×356 | WebP 288 | `#ff4800` |
| basecamp.com | inline SVG wordmark 197×30 | Apple icon PNG 512 | `#63b359` |
| github.com | inline SVG mark 32×32 | manifest PNG 512 | `#000000` |
| nytimes.com | favicon 48×48 (site blocks bots; icon only) | favicon 48 | `#121212` |
| openai.com | not found, free (site answers 403 to automated requests) | | |

One record (Stripe), shortened:

```json
{
  "input": "stripe.com",
  "domain": "stripe.com",
  "ok": true,
  "brandName": "Stripe",
  "brandColor": "#533afd",
  "logoUrl": "https://api.apify.com/v2/key-value-stores/…/records/stripe.com-logo.svg?signature=…",
  "iconUrl": "https://images.stripeassets.com/…/favicon.svg",
  "logoIsIcon": false,
  "logo": {
    "url": "https://api.apify.com/v2/key-value-stores/…/records/stripe.com-logo.svg?signature=…",
    "source": "inline-svg", "format": "svg", "width": 60, "height": 25, "bytes": 1922,
    "vector": true, "square": false, "hasTransparency": true,
    "dominantColor": "#031323", "colors": ["#031323"], "inline": true
  },
  "icon": {
    "url": "https://images.stripeassets.com/…/favicon.svg",
    "source": "link-icon", "format": "svg", "width": 512, "height": 512, "bytes": 412,
    "vector": true, "square": true, "hasTransparency": true,
    "dominantColor": "#533afd", "colors": ["#533afd"]
  },
  "storedLogoUrl": "https://api.apify.com/v2/key-value-stores/…/records/stripe.com-logo.svg?signature=…",
  "storedIconUrl": "https://api.apify.com/v2/key-value-stores/…/records/stripe.com-icon.svg?signature=…",
  "candidatesFound": 17,
  "candidates": ["… every file checked, with source, format, size, colours, logoScore, iconScore, error …"],
  "finalUrl": "https://stripe.com/",
  "httpStatus": 200,
  "ms": 1224,
  "checkedAt": "2026-09-23T22:31:06.530Z"
}
```

More inputs in [`examples/`](examples).

### Input

| Field | Default | What it does |
|---|---|---|
| `domains` | (required) | Domains, URLs or emails. Duplicates are removed. |
| `saveLogos` | `true` | Store the chosen logo and icon in the run's key-value store and return `storedLogoUrl` / `storedIconUrl`. Needed for inline SVG logos. |
| `includeCandidates` | `true` | Return every file checked, with scores, so you can pick differently (e.g. the largest PNG). |
| `minIconSize` | `16` | Ignore raster icons smaller than this (e.g. `64` for app tiles). SVGs always qualify. |
| `maxCandidates` | `10` | Files downloaded and measured per domain (best sources first, at most 3 per source). |
| `timeoutSecs` | `15` | Per-request timeout. |
| `maxConcurrency` | `10` | Domains processed in parallel. |
| `monitor` | `false` | Rebrand alerts: return only domains whose logo, icon or brand colour changed since the last monitor run (below). |
| `monitorKey` | (empty) | Name of the watchlist's saved state, so several can coexist. Empty = tied to the exact domain list. |

### Output

One dataset record per input. Key fields: `ok`, `domain`, `brandName`, `brandColor`, `themeColor`, `logoUrl`,
`iconUrl`, `logo` / `icon` objects (`source`, `format`, `width`, `height`, `bytes`, `vector`, `square`,
`hasTransparency`, `dominantColor`, `colors`, `icoSizes` for multi-size ICOs), `storedLogoUrl`, `storedIconUrl`,
`logoIsIcon`, `candidates`, `finalUrl`, `httpStatus`, `warning`, `error`.

`source` tells you where the file came from: `schema-org`, `og:logo`, `itemprop-logo`, `header-img`, `inline-svg`,
`apple-touch-icon`, `manifest`, `link-icon`, `mask-icon`, `ms-tile`, `favicon.ico`, `apple-touch-icon.png`, `og:image`.

The table view in the Apify Console shows the hosted logo and icon as images.

### Monitor mode: rebrand alerts

Set `"monitor": true` on a scheduled run to watch a list of companies. Logolark remembers each domain's logo and icon
(content hash, URL, format) and brand colour and, on the next monitor run, returns **only domains where something
changed**: a new logo file, a redrawn logo at the same URL, a new format (PNG → SVG) or a new brand colour.
Unchanged domains are left out and **not charged**. The first monitor run returns every domain as `"change": "new"`.

Noise is filtered out: hosted-copy links (`storedLogoUrl`), check times and a file that only moved to a new URL
(CDN, `?v=` cache-buster) with identical content don't count, and a failed check (site down, bot wall) keeps the
previous snapshot instead of reporting a removal.

```json
{ "domains": ["stripe.com", "shopify.com", "figma.com"], "monitor": true, "monitorKey": "portfolio-logos" }
```

A changed record carries `logoHash`, `iconHash` and these fields (structure shown; values depend on the site):

```json
{
  "domain": "acme.com",
  "change": "changed",
  "changedFields": ["logoUrl", "logoHash", "brandColor"],
  "changes": {
    "logoUrl": { "from": "https://acme.com/logo.svg", "to": "https://acme.com/brand/logo-new.svg" },
    "logoHash": { "from": "…", "to": "…" },
    "brandColor": { "from": "#e4572e", "to": "#0055ff" }
  }
}
```

A run summary (`new`, `changed`, `unchanged`, `failed`) is saved as the run's `OUTPUT` record. Hosted copies are
only saved for returned (new or changed) domains, so keep the `storedLogoUrl` links from earlier runs in your own storage.

### Pricing

**$0.002 per domain with a logo or icon found** (event `logo-resolved`), no start fee. Invalid inputs, unreachable or
bot-walled sites and domains with nothing usable are free. 1,000 companies cost at most $2.

For comparison (Apify Store, 23 Sep 2026): other logo Actors charge $0.0005–$0.02 per logo, most plus a start fee,
and the "Clearbit alternative" among them charges $0.02 per logo.

### Run it on a schedule

Apify Console → **Schedules** → **Create new** → cron `0 8 * * 1` (Mondays 8 AM) or `0 8 * * *` (daily) →
**Add Actor** → Logolark with your domain list and `"monitor": true`. With monitor mode a scheduled run is cheap:
you only pay for domains whose brand assets changed. The same schedule through the API:

```json
POST https://api.apify.com/v2/schedules?token=YOUR_TOKEN
{
  "name": "logolark-rebrand-watch",
  "cronExpression": "0 8 * * *",
  "timezone": "America/New_York",
  "isEnabled": true,
  "actions": [{
    "type": "RUN_ACTOR",
    "actorId": "cybermax/logo-finder",
    "runInput": {
      "body": "{\"domains\":[\"stripe.com\",\"shopify.com\",\"figma.com\"],\"monitor\":true,\"monitorKey\":\"portfolio-logos\"}",
      "contentType": "application/json"
    }
  }]
}
```

To get notified, open the Actor → **Integrations** and add an email, Slack or webhook notification on
"Run succeeded" (or use the Make/Zapier/n8n recipes below).

### Integrations

**API (synchronous):** `POST https://api.apify.com/v2/acts/cybermax~logo-finder/run-sync-get-dataset-items?token=YOUR_TOKEN`
with the input JSON returns the records directly. Typical latency: 1–3 s per domain.

**Make:** Apify app → "Run an Actor" (Actor `cybermax/logo-finder`, input `{"domains": ["stripe.com"]}`, run
synchronously) → "Get dataset items" → map `storedLogoUrl`, `iconUrl`, `brandColor` into your CRM or CMS.

**Zapier:** Apify app → "Run Actor" action (from a new CRM company or sheet row), or the "Finished Actor Run" trigger
on a scheduled monitor run → "Fetch dataset items" → update the record.

**n8n:** the Apify node ("Run an Actor and get dataset"), or an HTTP Request node:

```
POST https://api.apify.com/v2/acts/cybermax~logo-finder/run-sync-get-dataset-items?token=YOUR_TOKEN
{"domains": ["stripe.com", "jane@figma.com"], "includeCandidates": false}
```

**Google Sheets:** Apify's Google Sheets integration (Actor → Integrations), or pull the last run into a cell
(then `=IMAGE()` the `storedIconUrl` column):

```
=IMPORTDATA("https://api.apify.com/v2/acts/cybermax~logo-finder/runs/last/dataset/items?format=csv&fields=domain,brandName,logoUrl,iconUrl,brandColor&token=YOUR_TOKEN")
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("cybermax/logo-finder").call(run_input={"domains": ["stripe.com", "jane@figma.com"]})
for r in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(r["domain"], r.get("logoUrl"), r.get("brandColor"))
```

**JavaScript** (`npm i apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('cybermax/logo-finder').call({ domains: ['stripe.com', 'jane@figma.com'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**AI agents (MCP):** Logolark is a tool on Apify's MCP server, `https://mcp.apify.com/?tools=cybermax/logo-finder`
(Authorization: `Bearer YOUR_TOKEN`); the agent gets one tool that takes `{"domains": [...]}`. Claude Desktop / Cursor config:

```json
{ "mcpServers": { "logolark": { "url": "https://mcp.apify.com/?tools=cybermax/logo-finder",
  "headers": { "Authorization": "Bearer YOUR_TOKEN" } } } }
```

Typical agent prompts: "Add logos to this list of 200 leads", "What's Notion's brand colour?",
"Get a square 512 px icon for each of these SaaS tools for my comparison page".

### When NOT to use it

- **You only have a company name, not a domain.** Logolark needs a domain, URL or email. Find the domain first.
- **Sites behind a strong bot wall** (Cloudflare challenge, DataDome). Logolark uses plain HTTP from data-centre IPs
  with no proxy. Some such sites still serve `/favicon.ico` (returned with a `warning`); others return a free failure.
- **Brand kits and guidelines** (all logo variants, dark/light versions, fonts). Logolark returns what the website
  itself publishes, not a press kit.
- **Trademark clearance.** Logos are the companies' trademarks. Show them to identify the company (a CRM row,
  a directory listing, an integration list); don't use them to imply endorsement.
- **Permanent hosting.** Hosted copies live in the run's key-value store for your Apify plan's retention period
  (7 days on the free plan). Copy them to your own storage for long-term use.

### FAQ

**Is this a replacement for the Clearbit Logo API?** Yes, for the common use (`logo.clearbit.com/<domain>`): you
send domains and get a logo URL. Differences: Logolark reads the company's own site live instead of a cached
database, returns SVGs where the site has them, and gives you the icon and brand colour too. It is a batch API,
not an `<img src>` URL, so resolve once and store the result (`storedLogoUrl`) in your database.

**Why are there both `logoUrl` and `storedLogoUrl`?** `logoUrl` is the file on the company's own site (or the hosted
copy for inline SVGs, which have no URL). `storedLogoUrl` is always a copy in your Apify storage, safe to hotlink
during the retention period and immune to the site changing its file names.

**How is the best logo chosen?** Declared brand logos (schema.org, `og:logo`) first, then the logo in the header that
links to the homepage, preferring vector SVGs and transparent PNGs, and never a social-media card photo. Icons: square
only, SVG or the largest raster, preferring Apple/manifest icons over 16 px favicons. Every candidate and its score is in
`candidates`.

**Am I charged for misses?** No. Only records with `"ok": true` are charged.

**Does it respect sites?** It fetches only what a browser fetches on a first visit: the homepage, the manifest and
up to 10 small image files per domain, with a descriptive user agent. No crawling, no login, no personal data.

### Also from CyberMax

- [Hollerdex](https://apify.com/cybermax/website-contacts): emails, phones and social profiles for the same domains, to complete each CRM record.
- [DomainDNA](https://apify.com/cybermax/domain-intel): tech stack, email security (MX/SPF/DMARC) and domain age.
- [Linkheft](https://apify.com/cybermax/domain-authority): domain authority score and rank, to sort a directory or lead list.
- [Capturewren](https://apify.com/cybermax/website-screenshot): a screenshot and page text of each site, next to its logo.
- [HireHeat](https://apify.com/cybermax/hiring-signals): which of these companies are hiring right now.

All tools: [Insidewell](https://apify.com/cybermax/sec-insider-tracker) · [Swellmeter](https://apify.com/cybermax/google-trends) · [Gripeline](https://apify.com/cybermax/app-reviews) · [Keyfern](https://apify.com/cybermax/keyword-ideas) · [HireHeat Jobs](https://apify.com/cybermax/career-site-jobs) · [Printwren](https://huggingface.co/spaces/CyberMax-tools/docs-pages-as-pdfs?soon=html-to-pdf)

### Changelog

- 2026-09-23: Monitor mode (`monitor`, `monitorKey`: rebrand alerts when a logo/icon file, format or brand colour changes), schedule & integration recipes.

© 2026 CyberMax. All rights reserved.

# Actor input Schema

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

Companies to look up. Bare domains (stripe.com), full URLs (https://www.notion.so) or work emails (jane@figma.com, the domain part is used). Duplicates are removed.

## `saveLogos` (type: `boolean`):

Store the chosen logo and icon files in this run's key-value store and return stable links (storedLogoUrl, storedIconUrl). Needed for inline SVG logos, which have no URL of their own on the site.

## `includeCandidates` (type: `boolean`):

Also return every logo/icon the site publishes that was checked (source, format, size, colours, score), so you can choose differently.

## `minIconSize` (type: `integer`):

Ignore raster icons smaller than this (e.g. 64 for app tiles). SVG icons always qualify.

## `maxCandidates` (type: `integer`):

How many of the site's logo/icon files to download and measure (best sources first).

## `timeoutSecs` (type: `integer`):

Timeout for each HTTP request.

## `maxConcurrency` (type: `integer`):

How many domains to process at the same time.

## `monitor` (type: `boolean`):

For scheduled runs. Remembers each domain's logo, icon and brand colour and returns only domains that are new or whose logo or icon file (content hash, URL, format) or brand colour changed since the last monitor run, with change, changedFields and changes (from/to). Hosted-copy URLs and a file merely moving to a new URL with identical content don't count. Unchanged domains are left out and not charged; failed checks keep the previous snapshot. The first monitor run returns everything as new.

## `monitorKey` (type: `string`):

Optional. Name for this watchlist's saved state (e.g. portfolio-logos) so several watchlists can coexist and you can add or remove domains without starting over. Empty = derived from the domain list.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "https://www.shopify.com",
    "jane@figma.com"
  ],
  "saveLogos": true,
  "includeCandidates": true,
  "minIconSize": 16,
  "maxCandidates": 10,
  "timeoutSecs": 15,
  "maxConcurrency": 10,
  "monitor": false
}
```

# Actor output Schema

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

No description

## `files` (type: `string`):

No description

# 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",
        "https://www.shopify.com",
        "jane@figma.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cybermax/logo-finder").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",
        "https://www.shopify.com",
        "jane@figma.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cybermax/logo-finder").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",
    "https://www.shopify.com",
    "jane@figma.com"
  ]
}' |
apify call cybermax/logo-finder --silent --output-dataset

```

## MCP server setup

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

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/t2JM6gaQuRHnElpBd/builds/0U9RvQLOrSN1QKGfb/openapi.json