# Website Logo Finder - Company Logo URL, SVG, Size & Brand Color (`neverempty/website-logo-finder`) Actor

For CRMs, lead lists and AI agents: send domains or URLs, get each site's own logo URL (SVG or PNG from the header or JSON-LD, not a favicon copy) with measured width and height, where it was found, a confidence level, all icon candidates and the brand color. Sites with no logo are free.

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

## Pricing

from $4.50 / 1,000 logo founds

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?

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

## Website Logo Finder - Company Logo URL, SVG, Size & Brand Color

Send a list of domains or URLs. For each site you get **the URL of the site's own logo** - the SVG or PNG the site itself uses in its header or declares in its structured data - together with its **measured width and height**, **where it was found**, a **confidence level**, every other logo and icon candidate, the brand color and the site name.

Built for CRM enrichment, lead lists, directories, dashboards and AI agents that need "the logo URL of this company" many times a day.

```json
{ "urls": ["stripe.com", "https://www.shopify.com", "basecamp.com"] }
```

```json
{
  "status": "ok",
  "input": "https://www.shopify.com",
  "domain": "shopify.com",
  "siteName": "Shopify",
  "logoUrl": "https://cdn.shopify.com/shopifycloud/brochure/assets/brand-assets/shopify-logo-primary-logo-456baa801ee66a0a435671082365958316831c9960c480451dd0330bcdae304f.svg",
  "logoFormat": "svg",
  "logoWidth": 304.17,
  "logoHeight": 86.71,
  "logoSource": "json-ld",
  "confidence": "high",
  "iconUrl": "https://cdn.shopify.com/b/shopify-brochure2-assets/c97c60ca19c64a8b5378d9f9e971f7bd.png",
  "themeColor": null,
  "candidateCount": 8,
  "candidates": [ { "url": "...", "source": "json-ld", "format": "svg", "width": 304.17, "height": 86.71, "sizeFrom": "measured", "confidence": "high" } ]
}
```

### Input

| field | what it does |
|---|---|
| `urls` | Domains or URLs, 1 to 1,000 per run. `stripe.com` and `https://stripe.com/` both work. The same address twice is read and charged once. |
| `includeInlineSvg` | `true` to also return the markup of a logo that is drawn as inline SVG (default `false`). |
| `maxConcurrency` | Sites read in parallel, 1 to 8 (default 4). |
| `requestTimeoutSecs` | Seconds to wait for one answer, 5 to 60 (default 20). |

### What makes it different

- **The original file, not a re-encoded copy.** `logoUrl` points at the image on the site's own server or CDN, in its original format (SVG stays SVG, transparency is kept). Nothing is downloaded, converted or re-hosted.
- **Real dimensions.** The first 48 KB of the chosen image are read to measure `logoWidth` × `logoHeight` and the true format (a `.jpg` that is really WebP is reported as `webp`). The whole image is never fetched.
- **It says how sure it is.** `confidence` is `high` only when the site itself calls the image its logo (JSON-LD `Organization.logo`, `og:logo`, `itemprop="logo"`) or when it is an image with a logo hint inside the site header or a link to the home page. Declared app icons are `medium`. A bare favicon is `low` and the row says so. Nothing is promoted to `high` by guesswork.
- **Customer and partner logo walls are skipped.** Images that sit in a row of five or more (the "trusted by" strip), flags, social, payment and badge icons, and 1×1 tracking pixels are not candidates.
- **You pay only when a logo was found and loads.** A candidate is charged only after it answered as a real image. Sites with no logo, blocked sites and unreachable sites are free rows that say why.

### Where the logo comes from

`logoSource` and each entry in `candidates[].source` is one of:

| source | meaning | confidence |
|---|---|---|
| `json-ld` | `logo` of the Organization / WebSite in the page's JSON-LD | high |
| `og-logo`, `microdata` | `og:logo` meta tag, `itemprop="logo"` | high |
| `header-img` | `<img>` inside the site header or a link to the home page, with a logo hint in `alt`, `class`, `id` or file name | high (medium / low without a hint) |
| `apple-touch-icon`, `manifest-icon` | icons the site declares for home screens (Web App Manifest is read when the page links one) | medium |
| `icon`, `mask-icon` | `<link rel="icon">` (SVG or 64 px and larger: medium, smaller: low) | medium / low |
| `page-img`, `og-image` | an image elsewhere on the page whose name says "logo" | low |
| `favicon-ico` | `/favicon.ico`, requested only when the page declares no icon and added only if it loads | low |

`og:image` is returned in its own column (`ogImage`) and is not treated as a logo, because on most sites it is a social banner or an article photo.

### Output columns

`status`, `position`, `input`, `url`, `finalUrl`, `domain`, `httpStatus`, `siteName`, `siteNameSource`, `logoUrl`, `logoFormat` (svg, png, jpeg, webp, avif, gif, ico, bmp), `logoWidth`, `logoHeight`, `logoSource`, `confidence`, `logoContentType`, `logoAlt`, `iconUrl`, `iconWidth`, `iconHeight` (the best square icon, useful for avatars), `ogImage`, `themeColor`, `themeColorSource`, `backgroundColor`, `manifestUrl`, `manifestError`, `inlineSvgFound`, `inlineSvg`, `candidates`, `candidateCount`, `pageTitle`, `requestsMade`, `note`, `fetchedAt`.

In `candidates`, `sizeFrom` is `measured` (read from the image bytes) or `declared` (from the `sizes` attribute or the manifest, not checked). `checked` and `loads` tell you which candidates were actually requested. Up to 15 candidates are listed, best first.

#### Inline SVG logos

Many modern sites draw their logo as an `<svg>` element written directly into the page. Such a logo has no URL. `inlineSvgFound` is `true` when that is the case, and `logoUrl` then falls back to the best declared icon (usually `medium`). Turn on **Return inline SVG markup** to get the SVG markup itself (up to 20 KB) in `inlineSvg`.

### Pricing

Pay per event: one `logo-found` event for each site where a logo candidate was found and loaded as an image. No start fee.

Free rows (never charged): `no-logo-found`, `blocked`, `robots-disallowed`, `robots-unreachable`, `login-required`, `not-found`, `not-html`, `http-error`, `unreachable`, `unreadable`, `bad-input`, `budget-reached`. The same address given twice is read and charged once.

### Why not just a favicon?

A favicon is a small square icon. This Actor returns the site's real logo - often a wide SVG wordmark - together with its measured size, where on the site it was found and how far to trust it, so you can drop logos into a CRM, a directory or a report without checking each one by hand.

### How sites are read

- Only the address you give is read: one page per site, plus at most three small follow-up requests (the Web App Manifest if the page links one, and the first 48 KB of the best image candidates or `/favicon.ico`). `robots.txt` is read once per host and redirects are followed.
- **robots.txt is respected** for the page and for every image host (`User-agent: *`). A disallowed page is a free `robots-disallowed` row. A disallowed image is listed with `checked: false` and is never chosen as `logoUrl`.
- Check pages and refusals (CAPTCHA, HTTP 403) are not solved or bypassed, and no proxy is used to get around them. Such sites come back as free `blocked` rows.
- No browser is used. A logo that only appears after JavaScript runs, or that is a CSS background image, is not seen; the declared icons are returned instead.
- Speed: about 2 to 4 seconds per site, 4 sites at a time by default. 1 to 1,000 sites per run.

### Limits worth knowing

- The choice is made from the page's markup. On a small share of sites the best candidate is an app icon rather than the wordmark; `confidence` and `logoSource` tell you which one you got.
- `logoUrl` points at the site's own file. Sites change their assets; if you need the image permanently, download it on your side.
- Image dimensions for SVG come from its `width` / `height` attributes or its `viewBox`.

### Trademarks and usage rights

Logos are trademarks and copyrighted works of their owners. This Actor does not download, store or distribute any image: it returns the public URL where the site itself serves the file, plus its dimensions. Whether you may display, download or reuse a logo depends on your use case and on the owner's brand guidelines - checking that is your responsibility.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

## `urls` (type: `array`):

Websites to find the logo for, one per line (1 to 1,000 per run). A domain such as stripe.com or a full URL both work; without http:// or https:// the site is read as https://. The same address given twice is read and charged once. Only the address you give is read (one page per site). If this is empty, the example site https://apify.com is used.

## `includeInlineSvg` (type: `boolean`):

Some sites draw their logo as an <svg> element written directly into the page, so there is no image URL to return. The inlineSvgFound column always says when that is the case. Turn this on to also get the SVG markup itself (up to 20 KB) in the inlineSvg column. The logoUrl column and the charge are not affected.

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

How many sites are read in parallel (1 to 8). Requests to one site are always made one after another.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for one answer from a site (5 to 60).

## Actor input object example

```json
{
  "urls": [
    "stripe.com",
    "https://www.shopify.com",
    "basecamp.com"
  ],
  "includeInlineSvg": false,
  "maxConcurrency": 4,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

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

One row per site: the logo URL with its format, measured width and height, where it was found and a confidence level, the best square icon, all candidates, brand color and site name. A site with no logo, a site that robots.txt does not allow, a site that shows a check page or that cannot be reached comes back as a free row that says why.

# 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 = {
    "urls": [
        "stripe.com",
        "https://www.shopify.com",
        "basecamp.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/website-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 = { "urls": [
        "stripe.com",
        "https://www.shopify.com",
        "basecamp.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/website-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 '{
  "urls": [
    "stripe.com",
    "https://www.shopify.com",
    "basecamp.com"
  ]
}' |
apify call neverempty/website-logo-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/website-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/ZDVGkc2FUv0hyOGhC/builds/glKg4nC6oYN6Ebbl5/openapi.json