Website Image Scraper: 1,552 of 1,762 Runs Succeeded (2026)

Extracting 13 output fields per record, this HTTP-only crawler parses img tags, srcset candidates, picture sources, favicons, and inline background declarations without requiring a browser or proxy. Apify's free plan includes $5.00 of monthly usage with no credit card, covering up to 2,500 results of this Actor. It is built for developers and technical analysts auditing assets or migrating formats, and is not for anyone who needs downloaded binary files, which the records do not include.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 2,500 results at $0.002 each before platform usage. Open Website Image Scraper on Apify and run the prefilled example.

How reliable is Website Image Scraper in production?

Across the last 30 days of public runs on the Apify platform, Website Image Scraper recorded 1,762 runs with the following outcomes.

Outcome	Runs	Share
Succeeded	1,552	88.1%
Failed	23	1.3%
Aborted by the user	2	0.1%
Timed out	185	10.5%
Total	1,762	100.0%

When scheduling unattended runs, expect about 12 in a hundred runs to fail or time out, roughly one run in 8. Build around this telemetry by incorporating smaller input scopes or explicit retry logic.

What does it cost to run Website Image Scraper?

Each result costs $0.002 on Apify's free plan, which is $2.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Apify plan	Per result	Per 1,000 results
FREE	$0.002	$2.00
BRONZE	$0.00167	$1.67
SILVER	$0.00133	$1.33
GOLD	$0.001	$1.00
PLATINUM	$0.001	$1.00
DIAMOND	$0.001	$1.00

Worked example: collecting 10,000 results costs $20.00 in result charges before run-start fees and platform usage. With 11.8% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

Controlling the bill relies heavily on configuring maxTotalImages and maxCrawlDepth since they dictate how many items a run writes to the dataset. The run-start fee is charged every time a run starts, whether or not it returns results, while per-result charges apply only to results written to the dataset.

How do you run Website Image Scraper from the API?

The schema marks 1 of its 7 controls as required: startUrl. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Website Image Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~website-image-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrl":"https://apify.com","maxCrawlDepth":1,"maxImagesPerPage":200,"maxTotalImages":1000,"imageExtensions":["jpg","jpeg","png","gif","webp","svg","avif","bmp","ico"],"includeBackgroundImages":true}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "startUrl": "https://apify.com",
  "maxCrawlDepth": 1,
  "maxImagesPerPage": 200,
  "maxTotalImages": 1000,
  "imageExtensions": [
    "jpg",
    "jpeg",
    "png",
    "gif",
    "webp",
    "svg",
    "avif",
    "bmp",
    "ico"
  ],
  "includeBackgroundImages": True
}

run = client.actor("crawlerbros~website-image-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "startUrl": "https://apify.com",
  "maxCrawlDepth": 1,
  "maxImagesPerPage": 200,
  "maxTotalImages": 1000,
  "imageExtensions": [
    "jpg",
    "jpeg",
    "png",
    "gif",
    "webp",
    "svg",
    "avif",
    "bmp",
    "ico"
  ],
  "includeBackgroundImages": true
}

const run = await client.actor('crawlerbros~website-image-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Website Image Scraper inputs matter, and which can you skip?

Seven controls govern the crawl, with startUrl serving as the only required parameter. Most users should leave maxCrawlDepth at 1 and imageExtensions at their defaults on a first run to verify output structure quickly.

startUrl (string): The page to start crawling from (e.g. 'https://example.com'). The actor extracts images from this page and, if maxCrawlDepth >= 1, follows internal links to additional pages on the same host.
maxCrawlDepth (integer): 0 = only the start URL. 1 = also follow links found on the start URL (same host only). Higher values widen the crawl but cost more time. Default: 1.
maxImagesPerPage (integer): Cap on how many images are extracted from a single page. Pathological gallery pages can list hundreds of duplicates; this keeps runs bounded. Default: 200.
maxTotalImages (integer): Hard cap on the total number of image records pushed across all crawled pages. The crawl stops once this many images are emitted. Default: 1000.
imageExtensions (array): Only image URLs whose path ends in one of these extensions are kept. Drop entries to filter to a subset (e.g. only ['svg']) or extend with custom formats. Default: ["jpg","jpeg","png","gif","webp","svg","avif","bmp","ico"].
includeBackgroundImages (boolean): Also extract images referenced via inline style="background-image: url(...)" attributes. Disable to only collect <img>-sourced images. Default: true.
userAgent (string): Override the default Chrome User-Agent string. Most sites accept the default; only set this if a target server filters by UA.

What does Website Image Scraper return?

The output records are well-suited for asset inventories, format migration audits, and accessibility checks because they expose direct image paths, discovery sources, and alt text flags. However, they conspicuously do not contain the raw image binaries or decoded pixel streams.

url (e.g. https://apify.com/static/hero.jpg)
sourcePage (e.g. https://apify.com/)
pageTitle (e.g. Apify · The full-stack web-scraping & automat...)
alt (e.g. Apify hero image)
hasAltText (e.g. true)
title (e.g. Apify)
width (e.g. 1200)
height (e.g. 600)
extension (e.g. jpg)
discoveredVia (e.g. img-tag)
mimeTypeHint (e.g. image/jpeg)
crawlDepth (e.g. 0)
scrapedAt (e.g. 2024-12-16T14:23:11+00:00)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Website Image Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Provide a target in startUrl and keep maxCrawlDepth at 0 for an initial test against a single page.
Adjust maxImagesPerPage or maxTotalImages if the target host contains large galleries or extensive link trees.
Set imageExtensions to a subset of extensions if you only need specific formats such as svg or webp.
Toggle includeBackgroundImages to false if your analysis should exclude CSS background declarations.
Supply a custom string in userAgent only if the target host actively filters the default Chrome header.
Execute the run and inspect the returned dataset to confirm that discoveredVia and extension values populate as expected.

How do you apply it? Three worked playbooks

These are Website Image Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Content audits

Outcome: See every image a website serves up, broken down by source (img tag vs CSS background).

Configure: Set startUrl to the target domain, leave maxCrawlDepth at 1, and ensure includeBackgroundImages is true.

Working method: Run the crawler on the main landing page, group the resulting dataset by discoveredVia, and compare the count of img-tag entries against css-background entries.

Deliverable: A dataset of unique image records tagged with their discovery source and page title for audit reporting.

Stop condition: The run emits only sentinel error records due to missing markup or blocking headers.

Use case 2: Asset inventory

Outcome: Pull all logos, hero images, and icons from a competitor or brand site.

Configure: Set startUrl to the brand homepage, increase maxCrawlDepth to 2 to reach secondary navigation pages, and keep imageExtensions at default.

Working method: Filter the output dataset for items where discoveredVia is link-icon or where the url path contains common branding terms, then verify their dimensions via width and height.

Deliverable: A structured list of branding asset URLs ready for review or batch ingestion.

Stop condition: Total image records hit maxTotalImages before reaching key secondary pages.

Use case 3: Format migration

Outcome: Find every JPEG/PNG to convert to WebP/AVIF, or every PNG to convert to SVG.

Configure: Set startUrl to the target site and restrict imageExtensions to [jpg, jpeg, png].

Working method: Inspect the extension field in the output records to isolate legacy raster formats, then cross-reference with sourcePage to locate where they are embedded.

Deliverable: An inventory table of legacy image formats earmarked for conversion.

Stop condition: The returned extension field values do not match the requested filter array.

What breaks, and how do you design around it?

Over the last 30 days, 1.3% of public runs failed and 10.5% timed out. Build retries and alerting around those rates rather than assuming every run completes.

Because this scraper is HTTP-only, it relies on server-rendered HTML and cannot execute client-side scripts to catch lazy-loaded assets on heavy single-page applications. When targeting JavaScript-heavy frameworks where images fail to appear in the initial markup, switch to a browser-based approach.

When should you not use Website Image Scraper?

Do not use this Actor if you need to capture full-page graphical renderings or PDF snapshots of target pages, as it emits only structured text URLs rather than visual outputs; for that requirement, use Website Screenshot Generator. Avoid this tool if your primary objective is validating link health or discovering broken image hyperlinks across a site structure, in which case Find Broken Links is the correct alternative. Similarly, if your workflow depends on extracting business emails or social profiles rather than media URLs, look to Website Contact Finder. Finally, skip this Actor if you require a visual dependency network graph of page interconnections, which is handled by Website Links Graph Generator.

What should you check before trusting the output?

Verify that every record includes a non-null url string matching a valid absolute path.
Check that discoveredVia contains one of the supported source identifiers like img-tag or css-background.
Ensure that width and height are emitted as numeric values only when explicit pixel dimensions exist.
Monitor the dataset for the sentinel error record indicating that the target had no images found.
Confirm that hasAltText correctly evaluates to true or false based on the presence of alternative text.

None of this proves a record is correct. It gives a scheduled Website Image Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Does this Actor download the actual image binaries during a run?

No. The actor only collects URLs and metadata. Combine with a separate downloader or pipe URLs into Apify's standard URL list actor if you need the bytes.

How does the crawler handle pages built with JavaScript frameworks?

Mostly no. This scraper is HTTP-only and reads the server-rendered HTML rather than executing client-side scripts. If a site lazy-loads images via React or Vue, you may only see placeholder values.

Can I restrict the crawl to a single web page without following internal links?

Yes. Set maxCrawlDepth to 0. When configured this way, only the start URL is fetched and analyzed for image references.

What happens if the target website contains no images at all?

You receive a single sentinel record containing type website_image_scraper_error and reason no_images_found so the dataset remains non-empty while completing successfully.

How does the system handle duplicate image references across multiple pages?

Deduplication occurs by absolute URL. The same image referenced from multiple pages produces one record, where the first-seen page is recorded as the sourcePage.

Where to go next

When you are ready to run it, open Website Image Scraper on Apify; the free plan covers up to 2,500 results a month.

Start with the Website Image Scraper Actor page for the current input schema, pricing tier, and run history.

Readers running Website Image Scraper commonly pair it with:

Find Broken Links: Crawl a website (start URL + same-host pages up to a configurable depth) and report every link that returns a 4xx / 5xx status, times out, or has a DNS error.
Website Contact Finder: Crawl any website and extract emails, phone numbers, and social media profiles.
Website Links Graph Generator: Creates an oriented graph visualizing links between webpages.
Website Screenshot Generator: Capture full-page screenshots of any website as PNG images or PDF documents.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-23.
Actor last updated by its maintainers on 2026-05-01.
Run outcome figures cover the 30 day public window ending 2026-09-23.
Website Image Scraper on Apify