# Website Logo Extractor (`scrapers-hub/website-logo-extractor`) Actor

Website Logo Extractor detects and downloads brand logos from any URL, returning logo count and each logo's location. 🎨 Perfect for CRM enrichment, brand asset libraries, directory building and automated pitch deck creation.

- **URL**: https://apify.com/scrapers-hub/website-logo-extractor.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### 🖼️ Website Logo Extractor – Bulk Favicon, Brand Image & SVG Logo Scraper

The **Website Logo Extractor** pulls every logo, favicon and brand image it can find from a list of websites and returns them as clean, absolute URLs in a single dataset. Give it one domain or ten thousand, and for each one you get back the favicon set, the web-app-manifest icons, the Open Graph and Twitter Card images, any `<img>` tag that looks like a masthead logo, and the raw markup of every inline SVG on the page.

Logo extraction sounds trivial until you try it at scale. Brand marks are scattered across at least five different places in a modern HTML document, they are frequently declared as relative paths, sites ship four or five favicon variants at different pixel densities, and an increasing number of companies render their wordmark as inline SVG that never appears as an image file at all. This website logo extractor handles all of those cases in one pass and normalises every result to an absolute URL you can download immediately.

The actor is built on `curl_cffi`, an HTTP client that impersonates a real Chrome TLS fingerprint and header ordering instead of announcing itself as a Python script. There is no headless browser in the loop, so throughput is high and memory use is low. Proxy rotation is handled automatically inside the actor — there are no proxy credentials for you to configure — and each request is retried with a fresh IP and randomised backoff when a site responds with 403, 429 or 503.

***

### 📊 What Data Can You Extract with This Logo Scraper?

Every input URL produces exactly one dataset item. The item carries a small top-level envelope plus a `logos` array whose entries are typed, so you can filter by the kind of brand asset you actually want.

| Category | Fields | What it gives you |
|---|---|---|
| **Source identity** | `url` | The canonical URL that was processed, exactly as supplied after normalisation, so results stay traceable when items from many runs are appended into one dataset |
| **Result summary** | `logoCount` | The number of de-duplicated brand assets discovered on that site — a single integer you can sort, threshold or use as a coverage check |
| **Asset collection** | `logos` | An array of objects, one per discovered asset, each with its own `url`, `type` and `size` |
| **Asset classification** | `logos[].type` | One of `favicon`, `favicon-default`, `og-image`, `img-logo` or `svg-inline`, telling you where the asset came from |
| **Asset geometry** | `logos[].size` | The declared `sizes` attribute (for example `32x32`, `180x180` or `any`) when the site publishes one, otherwise `null` |
| **Vector markup** | `logos[].svgContent` | The complete inline `<svg>` element as a string, present only on `svg-inline` entries |
| **Failure reporting** | `error` | A human-readable reason when a site could not be fetched or decoded, so failures are visible in the data rather than only in the log |

The field most people underestimate is `logos[].type`. Because every asset is labelled at the point of discovery, you can write a one-line filter that keeps only `favicon` entries for a browser-style UI, only `og-image` entries for social preview cards, or only `img-logo` and `svg-inline` entries when you need the actual horizontal wordmark that appears in a site's header. Without that classification you would be guessing from filenames, which fails the moment a site names its logo `asset-4f2c.svg`.

***

### 🌟 Key Features of the Website Logo Extractor

| Feature | Description |
|---|---|
| 🔍 **Five discovery strategies in one pass** | Parses `<link rel="icon">` and friends, the web app manifest, Open Graph and Twitter meta tags, logo-like `<img>` elements, and inline `<svg>` markup — all from a single page fetch |
| 🧭 **Automatic favicon fallback probe** | Sends a lightweight `HEAD` request to `/favicon.ico` at the site root and records it as `favicon-default` when it exists, catching sites that never declare an icon in HTML |
| 📱 **Web app manifest parsing** | Follows `<link rel="manifest">`, fetches the JSON, and expands every entry in its `icons` array into a fully resolved URL with its declared size |
| 🎨 **Inline SVG capture** | Returns the complete `<svg>` markup in `svgContent`, so vector wordmarks that exist only inside the HTML are still recoverable |
| 🛡️ **Browser TLS impersonation** | Uses `curl_cffi` with a Chrome 120 fingerprint so requests look like a real browser at the transport layer, not like a scripting library |
| 🔁 **Retries with IP rotation** | Up to three attempts per URL, each with a new proxy session and randomised backoff, treating 403, 429 and 503 as retryable blocks rather than final answers |
| ⚡ **Configurable parallelism** | Processes up to `maxConcurrency` sites at once (default 10, maximum 50), so a large domain list finishes in a fraction of the sequential time |
| 🔗 **Absolute URL resolution** | Every relative `href`, `src`, `data-src` and manifest `src` is resolved against the final post-redirect URL, so nothing comes back as `/img/logo.png` |
| 🧹 **De-duplication built in** | Identical `(type, url)` pairs are collapsed before the item is pushed, so `logoCount` reflects distinct assets rather than repeated markup |

***

### 🚀 Why Choose This Logo Scraper?

**No headless browser means real throughput.** Chromium-based logo scrapers spend most of their runtime launching and tearing down browser contexts. This website logo extractor issues plain HTTP requests with a spoofed browser fingerprint, so a list of a few thousand domains is limited by network latency rather than by CPU. That directly affects both wall-clock time and compute cost on the platform.

**Coverage beats a naive favicon lookup.** Fetching `/favicon.ico` finds one asset and misses the rest. This actor checks that path too, but only as one of five strategies, which is why a single well-built marketing site can yield dozens of distinct assets — Apple touch icons, manifest icons at multiple densities, social preview images, header wordmarks and inline vector marks.

**Failures stay inside the dataset.** When a site cannot be fetched after its retries, the item is still pushed with `logoCount: 0`, an empty `logos` array and a populated `error` string. You never have to reconcile a dataset against an input list to work out which domains silently vanished, and re-running only the failed rows is a trivial filter.

**Zero proxy configuration.** Proxy rotation and session management are handled automatically inside the actor, including a fresh session identifier on every retry. There is nothing to buy, wire up or rotate yourself, and no proxy credentials appear anywhere in your input.

***

### 📥 Input

The logo scraper takes a plain list of URLs plus two optional performance controls. Bare domains are accepted — anything without a scheme is normalised to `https://` before the request is made.

```json
{
  "urls": [
    "https://apify.com",
    "https://stripe.com",
    "github.com"
  ],
  "maxConcurrency": 10,
  "timeoutSecs": 30
}
```

#### 🔧 Logo Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `urls` | array | ✅ Yes | `["https://apify.com"]` (prefill) | List of website URLs to extract logos, favicons and brand images from. Entries without `http://` or `https://` are automatically prefixed with `https://` |
| `maxConcurrency` | integer | No | `10` | Maximum number of URLs processed in parallel. Minimum 1, maximum 50 |
| `timeoutSecs` | integer | No | `30` | Timeout for each individual HTTP request. Minimum 5, maximum 120 |

#### 💡 Input Examples

**Single site, default settings**

```json
{
  "urls": ["https://apify.com"]
}
```

**Bulk brand audit across a domain list**

```json
{
  "urls": [
    "https://stripe.com",
    "https://shopify.com",
    "https://notion.so",
    "https://figma.com",
    "https://vercel.com"
  ],
  "maxConcurrency": 25
}
```

**Slow or heavily protected sites**

```json
{
  "urls": ["https://example-enterprise-portal.com"],
  "maxConcurrency": 3,
  "timeoutSecs": 90
}
```

***

### 📤 Output

Each dataset item describes one website. The example below is trimmed from a real run against `https://apify.com`, which returned 109 distinct assets.

```json
{
  "url": "https://apify.com",
  "logoCount": 109,
  "logos": [
    {
      "url": "https://apify.com/favicon.ico?favicon.2653ilt32bing.ico?dpl=d89ccaca32",
      "type": "favicon",
      "size": null
    },
    {
      "url": "https://apify.com/apple-touch-icon.png",
      "type": "favicon",
      "size": "180x180"
    },
    {
      "url": "https://apify.com/favicon.ico",
      "type": "favicon-default",
      "size": null
    },
    {
      "url": "https://apify.com/og-image.png",
      "type": "og-image",
      "size": null
    },
    {
      "url": "https://apify.com/assets/header-logo.svg",
      "type": "img-logo",
      "size": null
    },
    {
      "url": null,
      "type": "svg-inline",
      "svgContent": "<svg viewBox=\"0 0 120 32\" xmlns=\"http://www.w3.org/2000/svg\">…</svg>",
      "size": null
    }
  ]
}
```

#### 🧾 Website Logo Extractor Output Fields

| Field | Type | Description |
|---|---|---|
| `url` | string | null | Canonical URL of the scraped item |
| `logoCount` | integer | null | Number of de-duplicated logo and brand-image assets found for this site |
| `logos` | array | null | Logos values collected for the item — see the asset object table below |
| `error` | string | null | Error message, if the item failed to process |

**Asset objects inside `logos`**

| Field | Type | Description |
|---|---|---|
| `url` | string | null | Absolute URL of the asset, resolved against the final page URL. `null` for inline SVG entries, which have no file of their own |
| `type` | string | `favicon` (declared in HTML or the manifest), `favicon-default` (found at `/favicon.ico`), `og-image` (Open Graph or Twitter Card image), `img-logo` (an `<img>` matched as a logo), or `svg-inline` (inline vector markup) |
| `size` | string | null | The declared size, for example `32x32`, `512x512` or `any`, when the site publishes a `sizes` attribute. `null` otherwise |
| `svgContent` | string | The full inline `<svg>` element as a string. Present only on `svg-inline` entries |

***

### 💻 How to Use the Website Logo Extractor (Step by Step)

#### Step 1: Open the Logo Scraper and Load the Input Form

Open the actor on the Apify platform and switch to the **Input** tab. The form is deliberately short: a URL list and two performance dials. The `urls` field is pre-filled with `https://apify.com` so you can run it once and see the shape of the output before committing a real list. Everything else has a working default, so a first run needs no configuration at all.

#### Step 2: Build Your Website URL List

Paste your domains into the `urls` field, one per line. You can mix full URLs and bare domains — `github.com`, `https://github.com` and `https://github.com/` all resolve to the same request because the actor normalises anything missing a scheme to `https://`. If your list lives in a CRM export or a spreadsheet, extract the website column, strip obvious duplicates, and paste the result straight in. Redirects are followed automatically, so an old domain that now points somewhere else will still return the destination site's logos.

#### Step 3: Tune Concurrency for Your List Size

`maxConcurrency` controls how many sites are fetched at the same time and accepts 1 to 50. The default of 10 is a sensible middle ground. For a large list of unrelated domains, raising it to 25 or higher cuts total runtime substantially because each site is a separate host with its own rate limits. For a small list, or when several URLs point at the same domain, keep it low so you are not hammering one server with parallel requests.

#### Step 4: Set a Request Timeout That Matches Your Targets

`timeoutSecs` applies to each individual HTTP request, not to the run as a whole, and accepts 5 to 120 seconds. Fast marketing sites are comfortable at the default of 30. Enterprise portals, government sites and pages served from distant regions often need 60 to 90 before their first byte arrives. Setting the timeout too low is one of the most common causes of an `error` field appearing on sites that would otherwise have worked.

#### Step 5: Run the Logo Extractor and Watch the Log

Click **Start** and follow the log. Each site logs a `Processing <url>` line when it begins and a `Found N logos for <url>` line when it completes, so you can see progress in real time. Retry attempts are logged as warnings with the status code or exception that triggered them, which makes it easy to distinguish a site that is genuinely blocking from one that simply timed out on a slow first connection.

#### Step 6: Review the Dataset and Filter by Asset Type

Open the **Dataset** tab when the run finishes. Sort by `logoCount` to see which sites returned the richest asset set and which returned nothing. Then filter the `logos` array by `type` depending on what you are building: `favicon` and `favicon-default` for compact UI icons, `og-image` for social preview thumbnails, and `img-logo` plus `svg-inline` for full brand wordmarks. Rows carrying an `error` value are your retry queue.

#### Step 7: Export or Pipe the Results Downstream

Export the dataset as JSON, CSV, Excel or XML from the platform, or pull it through the API. Because every asset URL is absolute, a downstream script can download the files directly with no base-URL bookkeeping. For inline SVGs there is nothing to download at all — `svgContent` already holds the complete markup, ready to write to a `.svg` file or inject into a component.

***

### 🔌 API Access & Integrations

Run the website logo extractor synchronously and receive the dataset items in the same HTTP response:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~website-logo-extractor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://apify.com", "https://stripe.com"],
    "maxConcurrency": 10,
    "timeoutSecs": 30
  }'
```

The same run from Python using the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "urls": ["https://apify.com", "https://stripe.com"],
    "maxConcurrency": 10,
    "timeoutSecs": 30,
}

run = client.actor("scrapers-hub/website-logo-extractor").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("error"):
        print(f"FAILED {item['url']}: {item['error']}")
        continue
    print(f"{item['url']} -> {item['logoCount']} assets")
    for logo in item.get("logos") or []:
        if logo["type"] in ("img-logo", "svg-inline"):
            print("  wordmark:", logo["url"] or "(inline svg)")
```

Beyond direct API calls, runs and dataset items can be wired into Zapier, Make, Google Sheets, Slack and any HTTP endpoint through Apify's webhook integrations.

***

### 💡 Best Use Cases for Website Logo Data

#### 🏢 Building a Company Logo Database for a CRM or Directory

If you maintain a B2B directory, an investor database or a CRM with thousands of company records, run every stored website through this logo scraper and keep the highest-quality `img-logo` or manifest `favicon` entry per domain. The `size` field lets you prefer a 512×512 manifest icon over a 16×16 legacy favicon automatically, and `logoCount` tells you at a glance which records need a manual fallback.

#### 🎯 Competitive Brand Monitoring

Schedule the extractor against a fixed list of competitor domains and diff the `logos` array between runs. A new `og-image` value usually signals a repositioned marketing message; a changed `svg-inline` wordmark or `img-logo` URL is a strong signal of a rebrand, often visible weeks before it is announced.

#### 🔗 Rich Link Previews and Bookmarking Tools

Link preview cards need two things: an icon and a hero image. This actor returns both in one call — `favicon` or `favicon-default` for the small mark, `og-image` for the large preview. Because the URLs are absolute and post-redirect, a preview service can cache them straight away without re-resolving relative paths.

#### 📊 Marketing and Sales Collateral Automation

Pitch decks, comparison tables and customer logo walls all need clean brand marks at speed. Feed the account list from your pipeline into the `urls` field and collect the `img-logo` and `svg-inline` results; the SVG markup in `svgContent` scales to any slide size without the halo artefacts you get from upscaling a favicon.

#### 🧪 Web Asset and Accessibility Auditing

A site with `logoCount: 0` and no `error` is publishing no discoverable brand assets at all — no declared favicon, no manifest, no Open Graph image. That is a genuine SEO and social-sharing defect. Running the logo extractor across a portfolio of client sites surfaces those gaps as a sortable column rather than a manual page-by-page review.

#### 🤖 Training Data and Visual Search Pipelines

Brand-mark classifiers, logo-similarity search and trademark monitoring all need large volumes of labelled imagery. The `type` field gives you free weak labels, `logoCount` lets you drop low-signal domains, and the mix of raster URLs and `svgContent` vectors covers both bitmap and vector training paths.

#### 🛒 E-commerce Vendor and Marketplace Onboarding

Marketplaces that onboard hundreds of merchants can pre-populate each storefront profile with the merchant's own brand assets instead of asking for a manual upload. Pass the merchant's website through the scraper, take the largest manifest icon by `size`, and fall back to `og-image` when no square asset exists.

***

### ⚙️ Tips for Better Logo Scraping Results

- **Prefer manifest icons when you need square, high-resolution marks.** Entries with an explicit `size` such as `512x512` come from the web app manifest and are almost always cleaner than the legacy `/favicon.ico` fallback, which is frequently a 16×16 relic nobody has updated.
- **Filter `svg-inline` entries before storing them.** Sites often contain dozens of inline SVGs — chevrons, social icons, illustration fragments — and every one is captured. Keep the entries whose `svgContent` includes a `viewBox` with a wide aspect ratio, or that sit near the top of the array, since header markup is parsed in document order.
- **Raise `timeoutSecs` before you raise the retry count in your head.** Most `error` values reading "Failed to fetch page after retries" on otherwise healthy sites are slow first-byte responses, not blocks. Ninety seconds usually resolves them.
- **Keep `maxConcurrency` low when many URLs share one domain.** Parallelism helps across different hosts; against a single host it just increases the chance of a 429 and triggers retries that slow the run down overall.
- **Deduplicate your input list first.** The actor pushes one item per input entry, so a duplicated URL produces duplicated items and consumes compute twice.
- **Re-run failures separately rather than re-running the whole list.** Filter the dataset for a non-empty `error`, feed those URLs back in with a higher `timeoutSecs` and a lower `maxConcurrency`, and you will typically recover most of them.

***

### 🛠️ Troubleshooting

**Why does the run fail immediately with "No URLs provided in input"?**
The `urls` field is required and the actor stops as soon as it finds it empty. Blank lines and whitespace-only entries are stripped before processing, so a field that looks populated but contains only empty lines counts as empty. Add at least one valid URL and re-run.

**Why is `logoCount` zero with an `error` field set?**
The page could not be retrieved or its body could not be decoded. "Failed to fetch page after retries" means all three attempts failed — usually a timeout, a DNS failure, or a site that returned 403, 429 or 503 on every attempt with a fresh IP. "Could not decode response body" means the response arrived but its encoding could not be read. Increase `timeoutSecs`, reduce `maxConcurrency`, and try again.

**Why is `logoCount` zero with no `error` at all?**
The page was fetched and parsed successfully but genuinely contained no discoverable assets. This happens on single-page applications that inject their entire header after JavaScript execution, and on minimal landing pages with no declared icon, no manifest and no Open Graph tags. Because this logo scraper does not run a headless browser, client-side-rendered markup is not visible to it.

**Why do I get far more entries than the site appears to have logos?**
Every inline `<svg>` element counts as an asset, and modern component libraries emit a great many of them. A `logoCount` in the hundreds is normal for an icon-heavy marketing site. Filter the `logos` array by `type` to get to the small set you actually care about.

**Why does an `img-logo` entry point at something that is clearly not a logo?**
`<img>` elements are matched when the word "logo" appears in the `src`, `data-src`, `data-lazy-src`, `class`, `id` or `alt` attribute, or in the parent element's class or id. Partner badges, client logo walls and "as seen in" strips all legitimately match that rule. Combine the match with position in the array or with the image URL path when you need only the site's own mark.

***

### ❓ Frequently Asked Questions About Website Logo Scraping

**What does the Website Logo Extractor actually do?**
It fetches each website you supply, parses the HTML, and returns every favicon, web app manifest icon, Open Graph or Twitter Card image, logo-like `<img>` element and inline SVG it can find, as absolute URLs in a single dataset item per site.

**Do I need to download the logo files myself?**
Yes for raster and external vector assets — the actor returns URLs, not binary files, so you fetch the ones you want. Inline SVGs are the exception: their complete markup is already in `svgContent`, so nothing further needs to be downloaded.

**Can this logo scraper handle bare domains without https://?**
Yes. Any entry that does not start with `http://` or `https://` is automatically prefixed with `https://` before the request, so `github.com` and `https://github.com` behave identically.

**How many websites can I process in one run?**
There is no fixed cap in the input schema. Runtime scales with list size and with `maxConcurrency`, which accepts up to 50 parallel fetches, so large lists are practical in a single run.

**Does the website logo extractor use a headless browser?**
No. It uses `curl_cffi` with a Chrome 120 TLS fingerprint, which means real browser-like requests at HTTP speed without any rendering step. The trade-off is that content injected purely by client-side JavaScript is not visible.

**Do I need to configure proxies?**
No. Proxy rotation is handled automatically inside the actor, with a fresh session identifier generated for each retry attempt. There are no proxy fields in the input and no credentials to manage.

**What happens when a website blocks the request?**
Responses of 403, 429 and 503 are treated as retryable. The actor tries up to three times per URL, taking a new proxy session and waiting a randomised backoff between attempts. If all attempts fail, the item is still written with `logoCount: 0` and an `error` message.

**What is the difference between `favicon` and `favicon-default`?**
`favicon` entries were declared explicitly in the page — through `<link rel="icon">`, `apple-touch-icon`, `mask-icon` and similar, or through the web app manifest's `icons` array. `favicon-default` is the fallback found by probing `/favicon.ico` at the site root, and only appears when that file actually responds.

**How do I get the highest-resolution logo available?**
Filter `logos` for entries with a non-null `size`, parse the pixel dimensions, and take the largest. Those values come from declared `sizes` attributes on link tags and manifest icons, which is where high-density assets such as 192×192 and 512×512 are published.

**Can I extract logos from pages behind a login?**
No. The actor sends unauthenticated requests and there is no field for cookies, headers or credentials, so only publicly reachable pages can be processed.

**Does the logo extractor follow redirects?**
Yes. Redirects are followed automatically and relative asset paths are resolved against the final destination URL, so a domain that now redirects elsewhere still returns correctly resolved absolute URLs.

**Why do some `logos` entries have a `url` of `null`?**
Those are `svg-inline` entries. An inline SVG has no file of its own because it lives directly in the HTML, so the markup is returned in `svgContent` instead and `url` stays null.

**Can I use this website logo extractor on a schedule?**
Yes. Schedule it on the platform like any other actor and diff the `logos` array between runs to detect rebrands, new social preview images or changed favicon sets.

**What export formats are supported for logo data?**
The dataset can be exported as JSON, CSV, Excel, XML or RSS, or read through the API with `run-sync-get-dataset-items` and the `apify_client` libraries. Note that the nested `logos` array flattens awkwardly into CSV; JSON is the better choice when you need the full asset objects.

**Are the extracted logos free to use commercially?**
No. Logos and brand marks are trademarks belonging to their owners. This tool retrieves publicly published assets; it grants no licence, and how you use them remains your responsibility.

***

### 🆘 Support & Feedback

Found a bug, hit an unexpected `error` value, or want a field added? Open a ticket on the actor's **Issues** tab with the run ID and the input you used — that is the fastest route to a fix, and the run log tells us exactly which stage failed.

Need something custom? Bespoke asset-extraction rules, a different logo-matching heuristic, direct upload of downloaded files to your own storage, or a private version of this website logo extractor tuned to your list — email **scraperhubapi@gmail.com** and describe what you need.

If the logo scraper saves you time, please leave a review on the actor page. Ratings genuinely help other people find it, and the feedback shapes what gets built next.

***

### ⚖️ Disclaimer

The Website Logo Extractor retrieves only publicly accessible data from public web pages. It does not bypass authentication, does not access private or password-protected areas, and does not attempt to defeat access controls.

You are responsible for how you use the extracted data. Logos, wordmarks and brand imagery are typically protected by trademark and copyright law; retrieving an asset URL does not grant you any licence to reproduce, modify or redistribute the asset. Confirm your rights before using any brand mark in a commercial context.

Where extracted material relates to identifiable individuals, applicable privacy legislation including the GDPR and CCPA may apply. Establish a lawful basis for processing, keep only what you need, and honour data subject requests. Respect each website's Terms of Service and `robots.txt`, and keep request volumes reasonable.

For data removal requests, or if you believe content collected by this actor should not have been retrieved, contact **scraperhubapi@gmail.com** and we will respond promptly.

# Actor input Schema

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

List of website URLs to extract logos, favicons and brand images from.

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

Maximum number of URLs processed in parallel.

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

Timeout for each individual HTTP request.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com"
  ],
  "maxConcurrency": 10,
  "timeoutSecs": 30
}
```

# Actor output Schema

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

Records scraped by Website Logo Extractor, stored in the run's default dataset.

# 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": [
        "https://apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/website-logo-extractor").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": ["https://apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/website-logo-extractor").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": [
    "https://apify.com"
  ]
}' |
apify call scrapers-hub/website-logo-extractor --silent --output-dataset

```

## MCP server setup

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

```

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/wBe3aacMeykegxjos/builds/nwOQnU9e5VtVgnvk3/openapi.json