# Company Logo & Favicon Finder: Download Logos from Any Website (`data-done-right/company-logo-favicon-finder`) Actor

Company logo finder and favicon downloader. Give domains or URLs and get, per site, the best logo URL plus every favicon, apple-touch and manifest icon with size and format, ranked. Optional PNG resize, SVG kept, files saved with public links. Reads only the site itself. Pay per logo found.

- **URL**: https://apify.com/data-done-right/company-logo-favicon-finder.md
- **Developed by:** [Data Done Right](https://apify.com/data-done-right) (community)
- **Categories:** Developer tools, Automation, SEO tools
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.20 / 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

## Company Logo & Favicon Finder: Download Logos from Any Website

This **company logo finder** takes a list of domains or URLs and returns, for each site, the **best logo** plus **every favicon**, Apple touch icon and web-manifest icon with its real width, height and format. It works as a **favicon downloader** and a **website logo scraper** in one: bulk input, ranked results, optional PNG conversion, files saved with public links. No browser, no login, no third-party logo API.

What you get:

- `bestLogoUrl` with width, height, format and where it was found (JSON-LD, header image, app icon, social image, favicon).
- `faviconUrl` and `faviconUrls`: every working favicon, Apple touch icon, manifest icon and `/favicon.ico`.
- Optional saved files (`storedFileUrl`, `storedFaviconUrl`) as originals or PNG, and a ranked `candidates` list for your own selection.

Logos, icons and brand names belong to their owners. This Actor only finds and copies files that a website publishes openly; you are responsible for having the right to use them (see the FAQ).

### What does the Company Logo & Favicon Finder return

For each domain, the Actor loads the homepage (or the URL you give) and collects candidates from, in this order of trust:

1. `<link rel="icon">`, `shortcut icon`, `apple-touch-icon` and `mask-icon` tags.
2. The icons listed in the site's web manifest (`manifest.json` / `.webmanifest`).
3. `og:image` and `twitter:image` meta tags.
4. JSON-LD `Organization` (and `WebSite`, `Brand`...) `logo` values.
5. `<img>` elements in the header with a logo-like class, id, alt text or file name.
6. `/favicon.ico` on the site's root as a last resort.

It then downloads each candidate (up to 16 per site, the most promising first), checks that it is a real image, measures it, and ranks it. SVG logos are kept as vector files, an ICO is measured by its largest frame, and a candidate that is really an HTML error page is rejected. SVG files that contain scripts are never returned as a best logo and never saved.

### How to find company logos from a list of domains

1. Paste the domains in **Domains or URLs**, one per line (`python.org`, `https://apify.com/pricing`).
2. Leave **Save files** on `bestLogo` to get a public link to the logo file, or set it to `none` for links only.
3. Run it and download the dataset as JSON, CSV or Excel. The **Logos and favicons** view shows the logo image next to the status.

### How to download favicons from many websites

Set **Save files** to `bestLogoAndFavicon`. The best tab favicon is saved next to the logo and linked in `storedFaviconUrl`. Every other working icon is listed in `faviconUrls`. Choose `allReachable` to save every candidate (logo, icons, social images) as separate files.

### How to convert logos and favicons to PNG

Set **Output format** to `png` and **PNG size** to the longest side you need (for example `64` or `256`). Rasters are scaled down to fit, never enlarged. An ICO becomes a PNG of its largest frame. SVG files are always kept as SVG, because turning them into a bitmap would lose quality. The row shows the real size of the delivered file in `storedFileWidth` and `storedFileHeight`.

### How to pick only large or vector logos

Set **Minimum logo size** (for example `128`) so tiny favicons are not chosen as `bestLogoUrl`; the status becomes `favicon_only` when icons exist but none is big enough. **Prefer SVG** ranks vector logos higher. Turn it off if you need a bitmap.

### Input example

```json
{
  "domains": ["python.org", "apify.com", "github.com"],
  "download": "bestLogoAndFavicon",
  "outputFormat": "original",
  "minSize": 0,
  "preferSvg": true,
  "includeCandidates": true
}
```

| Input | Default | What it does |
|---|---|---|
| `domains` (required) | python.org, apify.com, github.com | Domains or URLs, one per line. Duplicates run once. |
| `maxDomains` | 100 | Most domains per run (1 to 5,000). Extra ones are not fetched or charged. |
| `download` | `bestLogo` | `none`, `bestLogo`, `bestLogoAndFavicon` or `allReachable`. |
| `outputFormat` | `original` | `original` or `png`. SVG always stays SVG. |
| `pngSize` | 256 | Longest side in px for PNG output. 0 keeps the size. |
| `minSize` | 0 | Raster candidates below this longest side cannot be the best logo. SVG always passes. |
| `preferSvg` | true | Rank vector logos higher. |
| `includeCandidates` | true | Add the full ranked `candidates` list to each row. |
| `concurrency` | 5 | Domains processed in parallel (1 to 20). |
| `perHostDelayMs` | 250 | Minimum pause between two requests to one host. |
| `outputStoreName` | empty | Named key-value store for the files (kept after the run). |
| `proxyConfiguration` | none | Optional Apify proxy. |

### Output example

Real output (shortened) for `apify.com`:

```json
{
  "index": 2,
  "input": "apify.com",
  "domain": "apify.com",
  "finalUrl": "https://apify.com/",
  "status": "ok",
  "error": null,
  "bestLogoUrl": "https://apify.com/img/apify-logo/apify-symbol-200x200.svg",
  "bestLogoSource": "jsonld-logo",
  "bestLogoFormat": "svg",
  "bestLogoWidth": 200,
  "bestLogoHeight": 200,
  "faviconUrl": "https://apify.com/icon0.svg",
  "faviconUrls": ["https://apify.com/icon0.svg", "https://apify.com/apple-icon.png", "https://apify.com/icon6.png", "https://apify.com/favicon.ico"],
  "storedFileUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/apify.com_logo.svg",
  "storedFaviconUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/apify.com_favicon.svg",
  "storedFileKey": "apify.com_logo.svg",
  "storedFileFormat": "svg",
  "candidateCount": 17,
  "candidates": [
    {"url": "https://apify.com/img/apify-logo/apify-symbol-200x200.svg", "type": "jsonld-logo", "source": "json-ld", "format": "svg", "width": 200, "height": 200, "reachable": true, "score": 155.0},
    {"url": "https://apify.com/apple-icon.png", "type": "apple-touch-icon", "source": "html-link", "format": "png", "width": 180, "height": 180, "reachable": true, "score": 80.5},
    {"url": "https://apify.com/favicon.ico", "type": "favicon-ico", "source": "fallback", "format": "ico", "width": 48, "height": 48, "reachable": true, "score": 17.8}
  ]
}
```

`status` is one of:

- `ok`: a logo was found (charged).
- `favicon_only`: icons exist but none met `minSize`, or only mask icons were found (charged).
- `not_found`: the site loaded but no usable image was found (free).
- `failed`: the site could not be reached and no `/favicon.ico` exists (free). The reason is in `error`.
- `skipped`: the spending limit was reached before this domain (free).
- `invalid_input`: not a valid domain or URL (free).

If the homepage fails (for example HTTP 403) but `/favicon.ico` works, you still get a row with `status: ok`, and `error` says why the page could not be read. The `FAILED` record in the key-value store lists every domain that was `failed`, `not_found` or invalid. `SUMMARY` has the run totals.

### How much does it cost to find company logos

Pay per event: **$0.0065 per logo or favicon found** (event `logo-found`, $6.50 per 1,000), plus normal Apify platform usage, which is small. Each domain is charged once, only when its status is `ok` or `favicon_only`. `not_found`, `failed`, `skipped` and invalid rows are free. Set a maximum spending limit and the run stops cleanly when it is reached.

| Domains | Logo-found charges | Charge |
|---|---|---|
| 1,000 (about 900 found) | 900 | about $5.85 |
| 10,000 (about 9,000 found) | 9,000 | about $58.50 |
| 100,000 (about 90,000 found) | 90,000 | about $585 |

If every domain has a logo, the charge is $6.50, $65 and $650. The found rates above are an example: some sites have no usable image or block normal requests.

### Use cases

- Fill a CRM, directory or sales dashboard with company logos from a list of customer or lead domains.
- Build a logo wall or "trusted by" strip from your own customer list, after checking you may show those logos.
- Download favicons for a bookmark manager, link preview, RSS reader or analytics report.
- Collect competitor logos in SVG for a comparison page or a design review.
- Audit your own sites: which icons and sizes does each page really publish, and does `/favicon.ico` exist?

### Use with the Apify API, MCP, n8n and Make

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("<username>/company-logo-favicon-finder").call(run_input={
    "domains": ["python.org", "apify.com"], "download": "bestLogo"})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["domain"], row["bestLogoUrl"], row["bestLogoWidth"], row["bestLogoHeight"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('<username>/company-logo-favicon-finder').call({
    domains: ['python.org', 'apify.com'], download: 'bestLogo' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((r) => [r.domain, r.bestLogoUrl]));
```

For MCP clients, connect the Apify MCP server and call this Actor with the same input; the first fields of the description tell an agent what it returns. In n8n or Make, use the Apify node or module "Run Actor", then read the dataset items.

### Limits (honest)

- It reads the **HTML the server sends**. Logos that a script adds after load, or that are inline `<svg>` markup or CSS background images, are not seen (no browser is run). Favicons, manifest icons, social images and JSON-LD are still found for most sites.
- One page per domain (the homepage or the URL you give), one manifest, and at most 16 candidate files. It does not crawl a site.
- "Best logo" is a ranking by source, size, aspect ratio and type. It is usually right for company sites; a social image or a favicon can win when a site has no better logo, and some sites use an unusual header. Check the `candidates` list when it matters.
- Sites that block normal requests (403, bot walls, CAPTCHAs) give an error row; there is no bot-protection evasion. A proxy may help on some sites. Login-walled social sites (Facebook, Instagram, LinkedIn, X, TikTok) are not read as pages.
- Pages and files on private or internal addresses are refused.
- Files are limited to 5 MB each. Animated images keep only the first frame when converted to PNG.

### FAQ

**Does it use Clearbit, Google favicon service or any other logo API?** No. It reads the website itself, so there is no third-party service in the loop and no extra key to manage.

**Can I use the logos commercially?** Logos, trademarks and icons belong to their owners. This Actor does not grant any rights and makes no claim that a logo is free to use. Check the brand's guidelines or ask the owner before you publish a logo, particularly in marketing or in a way that suggests a partnership.

**Why is the best logo a favicon or a social image?** The site publishes nothing better in its HTML. The ranking prefers a JSON-LD logo, a header logo, then app icons, then favicons and social images, and it lowers wide banner images. Look at `candidates` to pick another one.

**Are failed domains charged?** No. Only `ok` and `favicon_only` rows are charged, once per domain.

**Does it run JavaScript or work on single-page apps?** No. A site that renders everything in the browser may only expose its favicons and `/favicon.ico`.

**How many domains per run?** Up to 5,000 (default 100). Use `concurrency` to speed up large lists; requests to one host are spaced out by `perHostDelayMs`.

**What does it NOT do?** It does not guess a company's website from its name, extract brand colors, remove backgrounds, or check trademarks.

### Related tools

- **Meta Tags & Open Graph Extractor: Title, SEO, Twitter Cards** for titles, descriptions and social tags of the same pages.
- **Image Compressor & Resizer: Compress Images in Bulk** for shrinking the logos you downloaded.
- **Download Images from URLs: Bulk Image & File Downloader** for downloading other images from pages or link lists.

# Actor input Schema

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

Websites to find logos for, one per line. A bare domain or a full URL works. Example: python.org or https://apify.com/pricing. Duplicates are processed once.

## `maxDomains` (type: `integer`):

Most domains processed in this run (1 to 5,000). Extra domains are not fetched and not charged. Example: 100.

## `download` (type: `string`):

Which files to save. Saved files get a public link in storedFileUrl and storedFaviconUrl. Example: bestLogoAndFavicon.

## `outputFormat` (type: `string`):

With PNG, raster logos and favicons are saved as PNG (an ICO uses its largest frame). SVG files are always kept as SVG.

## `pngSize` (type: `integer`):

When converting to PNG: fit the longest side to this many pixels, keeping the aspect ratio. Smaller images are not enlarged. 0 keeps the size. Example: 256.

## `minSize` (type: `integer`):

Ignore raster candidates whose longest side is below this for bestLogoUrl. SVG always passes. 0 = no minimum. Example: 128 skips 16 px favicons.

## `preferSvg` (type: `boolean`):

Rank vector (SVG) logos above raster images of similar quality. Turn off if you need a bitmap.

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

Add the full ranked candidates list (url, type, format, width, height, score) to every row. Turn off for slimmer rows.

## `concurrency` (type: `integer`):

Domains processed at the same time (1 to 20). Requests to one host are always spaced out. Example: 5.

## `perHostDelayMs` (type: `integer`):

Minimum pause between two requests to the same host, in milliseconds. Example: 250.

## `outputStoreName` (type: `string`):

Optional. Save files in a named store that is kept after the run, for example logo-library. Empty uses the run's default store.

## `proxyConfiguration` (type: `object`):

Optional. Use an Apify proxy if sites refuse requests from the platform's addresses. Not needed for most sites.

## Actor input object example

```json
{
  "domains": [
    "python.org",
    "apify.com",
    "github.com"
  ],
  "maxDomains": 100,
  "download": "bestLogo",
  "outputFormat": "original",
  "pngSize": 256,
  "minSize": 0,
  "preferSvg": true,
  "includeCandidates": true,
  "concurrency": 5,
  "perHostDelayMs": 250
}
```

# Actor output Schema

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

One row per domain (the default dataset): best logo, favicons and candidates, as JSON, CSV, Excel and more.

## `records` (type: `string`):

Key-value store records: saved logo and favicon files, SUMMARY (run totals) and FAILED (domains with problems).

# 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": [
        "python.org",
        "apify.com",
        "github.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data-done-right/company-logo-favicon-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": [
        "python.org",
        "apify.com",
        "github.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("data-done-right/company-logo-favicon-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": [
    "python.org",
    "apify.com",
    "github.com"
  ]
}' |
apify call data-done-right/company-logo-favicon-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data-done-right/company-logo-favicon-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/sTkOmrzp9WkbyUu7O/builds/hYrYh0LOgnefQUcOB/openapi.json