# Logo & Favicon Extractor – Website Logos in Bulk (`innovative_cookie/logo-favicon`) Actor

Get any website’s logo and favicon in bulk: link icons, apple-touch-icon, manifest, JSON-LD, og:image. Real sizes and formats, optional download.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Logo & Favicon Extractor – Get Any Website's Logo, Favicon and Icons in Bulk

**Logo & Favicon Extractor** finds the **logo and favicon of any website** from a list of domains. For each site it reads the icons the site declares in its HTML and web app manifest, measures their **real format and pixel size**, picks the **best favicon** and the **best logo**, and can save the image files to the key-value store so you get a direct download link for each one.

Use it to enrich a CRM or a lead list with company logos, build a "trusted by" wall, show favicons next to links in an app, or audit a portfolio of sites for missing or low-resolution icons.

It is a light HTTP actor with no browser, so it is fast and cheap to run. It **respects robots.txt** and does not try to get past captchas or anti-bot pages.

### What does it extract?

| Source | Where it comes from |
|---|---|
| `icon`, `shortcut icon` | `<link rel="icon">` tags, including `sizes` and `type` |
| `apple-touch-icon` | `<link rel="apple-touch-icon">` (and `-precomposed`), usually a 180×180 PNG |
| `mask-icon`, `fluid-icon` | Safari pinned-tab SVG, GitHub-style large icons |
| `manifest` | Icons listed in the web app manifest (`manifest.json` / `site.webmanifest`) |
| `json-ld-logo` | `"logo"` of an `Organization` in schema.org JSON-LD |
| `og-logo`, `og-image`, `twitter-image` | Open Graph and Twitter Card meta tags |
| `img-logo`, `inline-svg-logo` | The logo image or inline SVG in the page header (home link, "logo" class or alt text) |
| `msapplication-TileImage` | Windows tile icon |
| `/favicon.ico`, `/apple-touch-icon.png` | Conventional fallback locations, probed only when the page does not declare them |

For every candidate you get the URL, source, declared sizes and type, **real format** (png, svg, ico, jpg, webp, gif, avif), **real width and height**, file size in bytes, and for `.ico` files all the sizes inside the file.

#### How is the "best" icon chosen?

- **Best favicon**: the largest square icon (an SVG counts as scalable), from icon, apple-touch-icon, manifest or `/favicon.ico`.
- **Best logo**: in order of reliability: JSON-LD logo, `og:logo`, header `<img>` logo, header inline SVG, then the largest manifest or touch icon. Social sharing images (`og:image`) are often banners, so they are reported separately as `ogImageUrl` and are not used as the logo.

### How to use it

1. Paste your domains or homepage URLs into **Websites**, one per line (`apify.com`, `https://www.example.org`).
2. Keep **Save images** on if you want downloadable files. With **Save only the best** on, you get at most two files per site (favicon and logo).
3. Click **Start**. Each site gives one result row; images appear in the key-value store.

#### Input example

```json
{
    "urls": ["apify.com", "github.com", "https://www.lemonde.fr"],
    "saveImages": true,
    "saveOnlyBest": true,
    "measureImages": true,
    "probeFallbacks": true,
    "maxIconsPerSite": 12,
    "maxImageMB": 5,
    "maxConcurrency": 5,
    "requestDelayMs": 250
}
```

#### Output example

```json
{
    "input": "https://stripe.com/",
    "domain": "stripe.com",
    "status": "ok",
    "finalUrl": "https://stripe.com/fr",
    "siteName": "Stripe | Plateforme et solution de paiement en ligne",
    "bestFaviconUrl": "https://images.stripeassets.com/.../favicon.svg",
    "bestFaviconFormat": "svg",
    "bestFaviconWidth": 512,
    "bestFaviconHeight": 512,
    "bestFaviconKvUrl": "https://api.apify.com/v2/key-value-stores/<id>/records/stripe.com-favicon-5e46bc41.svg",
    "bestLogoSource": "inline-svg-logo",
    "bestLogoFormat": "svg",
    "bestLogoKvUrl": "https://api.apify.com/v2/key-value-stores/<id>/records/stripe.com-logo-e4a24638.svg",
    "ogImageUrl": "https://b.stripecdn.com/.../stripe.37119086.jpg",
    "iconCount": 6,
    "icons": [
        { "source": "icon", "format": "svg", "width": 512, "height": 512, "bytes": 412, "key": "stripe.com-favicon-5e46bc41.svg" }
    ]
}
```

Export the dataset as JSON, CSV, Excel or HTML, or read it through the Apify API. A `SUMMARY` record in the key-value store gives the totals for the run.

#### Status values

| status | Meaning |
|---|---|
| `ok` | At least one icon or logo found |
| `no-icons` | The page declares nothing and the fallbacks do not exist |
| `blocked-by-robots` | robots.txt disallows this bot, or robots.txt is unreachable (5xx) |
| `blocked-by-anti-bot` | The site answered with a captcha or a bot challenge (or HTTP 401/403/429). It is **not bypassed** |
| `error` | DNS error, timeout, HTTP error on the homepage, invalid URL |

### Pricing

The Actor itself is **free to use**: there is no Actor fee for now. You only pay the Apify platform usage of your runs (compute units and data transfer), which stays small because the Actor uses plain HTTP requests, without a browser or proxy. The Apify Free plan includes $5 of monthly credit, which covers a lot of test runs.

### Responsible use

- **robots.txt is respected** for the homepage, the manifest, every image and every redirect hop. `Crawl-delay` is honoured (up to 10 s).
- Requests to the same site are sequential and spaced by `requestDelayMs`. The bot identifies itself with the `LogoFaviconFetcher/1.0` user agent.
- Captchas, Cloudflare/DataDome/PerimeterX challenges and other anti-bot pages are **never circumvented**. The site is reported as `blocked-by-anti-bot`.
- Only public http(s) URLs are fetched; private and local addresses are refused.
- The actor collects **no personal data**, only images and metadata that sites publish for browsers.

**Trademarks:** logos are usually trademarks of their owners. This actor only retrieves what each site publishes; you are responsible for using the images within the owner's brand guidelines and the law (for example, showing a company's logo next to its name is usually fine, but suggesting an endorsement is not).

### FAQ

**Can I get a logo in high resolution?**
The actor reports every size it finds, so choose the largest. SVG logos and favicons (very common today) scale to any size.

**Why does `bestLogoUrl` start with `data:image/svg+xml`?**
Many sites draw their logo as an inline SVG inside the HTML, with no separate file. The actor captures that SVG; turn on *Save images* to get it as a real `.svg` file with a download link.

**Why is a well-known site `blocked-by-anti-bot`?**
Some sites put every automated request behind a captcha or a bot wall, sometimes even their robots.txt. The actor stops there by design.

**Does it run JavaScript?**
No. Icons and logos are almost always in the server HTML. Single-page apps that inject their icons with JavaScript still usually serve `/favicon.ico` and a manifest, which the actor finds.

**Can I use it through the API or with Make, Zapier or n8n?**
Yes. Like any Apify actor, you can run it through the Apify API, on a schedule, or from automation tools, and read the dataset and images by URL.

### Related actors

More Actors by the same author ([innovative_cookie on Apify](https://apify.com/innovative_cookie)):

- [Sitemap URL Extractor](https://apify.com/innovative_cookie/sitemap-extractor): list every URL of a website from its XML sitemaps.
- [PageSpeed Insights Bulk Checker](https://apify.com/innovative_cookie/pagespeed-bulk): Core Web Vitals and Lighthouse scores for many URLs.
- [Bulk Domain Availability Checker](https://apify.com/innovative_cookie/domain-availability): check whether domain names are free via RDAP.
- [Bulk Image Converter & Compressor](https://apify.com/innovative_cookie/image-converter): convert and compress images to WebP, AVIF, JPEG or PNG.
- [Website Image Extractor](https://apify.com/innovative_cookie/website-image-extractor): list every image of a page with size, format and alt text.

# Actor input Schema

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

Domains or homepage URLs (one per line), e.g. apify.com or https://www.example.org.

## `saveImages` (type: `boolean`):

Store the image files so you can download them (direct links in the results).

## `saveOnlyBest` (type: `boolean`):

When off, every icon found is stored.

## `measureImages` (type: `boolean`):

Download each candidate to read its real format and pixel size (needed to pick the best one). Turn off to only list declared URLs (faster).

## `includeSocialImages` (type: `boolean`):

Social sharing images are often banners, not logos; they are reported separately as ogImageUrl.

## `probeFallbacks` (type: `boolean`):

Check the conventional locations when the page does not declare them.

## `maxIconsPerSite` (type: `integer`):

Limit the number of candidates checked per site.

## `maxImageMB` (type: `integer`):

Larger files are skipped.

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

Requests to the same site are always sequential and spaced.

## `requestDelayMs` (type: `integer`):

Politeness delay per host; robots.txt crawl-delay is honoured when larger.

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

Timeout per request.

## Actor input object example

```json
{
  "urls": [
    "apify.com",
    "github.com",
    "wikipedia.org"
  ],
  "saveImages": true,
  "saveOnlyBest": true,
  "measureImages": true,
  "includeSocialImages": true,
  "probeFallbacks": true,
  "maxIconsPerSite": 12,
  "maxImageMB": 5,
  "maxConcurrency": 5,
  "requestDelayMs": 250,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with one row per result

## `summary` (type: `string`):

SUMMARY record

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

Stored logos and favicons

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

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

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

```

## MCP server setup

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

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/WrB2oGqJ18QUCgn9f/builds/OhogdZmA4gUB3eP7l/openapi.json