Extract Images from {Website}

A website image scraper API for developers.

Turn a page URL into image URLs, SVGs, CSS backgrounds, and responsive sources with alt text. Add browser controls for JavaScript-heavy pages and image enrichment for catalogs and computer vision datasets.

Get API AccessNo card required

View Documentation

What You Get

Get a structured image inventory, then add the metadata your workflow needs.

Image URLs and embedded assets

Extract img and responsive sources, inline SVGs, base64 data, CSS backgrounds, favicons, metadata images, and video posters.

Image URLs and alt text

Each image includes url and alt. Keep the source page URL alongside its images for traceable catalog and dataset records.

Optional image enrichment

Request measured width and height, visual asset classification, or hosted image URLs. Enrichment fields are returned when processing succeeds.

Visual deduplication

Set imageParams.dedupe to visual to keep the highest-resolution copy of each visual duplicate group on a page. Images that cannot be downloaded or hashed are kept.

How to extract images from a website

An image scraping API takes a webpage URL and returns the images it finds as structured data. Context.dev handles page rendering and extraction behind one endpoint.

Create an API key, set CONTEXT_DEV_API_KEY in your server environment, and replace the example URL with your target page. For JavaScript or TypeScript, use the native fetch example with your server-side API key.

cURL

Shell

curl --request POST 'https://api.context.dev/v1/web/scrape' \
  --header "Authorization: Bearer $CONTEXT_DEV_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
  "url": "https://example.com/products/canvas-bag",
  "formats": {
    "images": true
  }
}'

JavaScript / TypeScript

TypeScript

const response = await fetch("https://api.context.dev/v1/web/scrape", {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "url": "https://example.com/products/canvas-bag",
    "formats": {
      "images": true
    }
  }),
});

if (!response.ok) throw new Error(await response.text());
const data = await response.json();
console.log(data.images.data);

Read images.data from the response. Each entry includes url and alt. One request processes one page; use your own page list for a whole site.

API response

Illustrative image response from the unified Scrape API. Actual results depend on the target page.

POST /v1/web/scrape

Try in playground

Request body

{
  "url": "https://example.com",
  "formats": {
    "images": true
  }
}

Example response

{
  "url": "https://example.com/",
  "html": {
    "requested": false,
    "success": null,
    "data": null
  },
  "markdown": {
    "requested": false,
    "success": null,
    "data": null
  },
  "screenshot": {
    "requested": false,
    "success": null,
    "data": null
  },
  "images": {
    "requested": true,
    "success": true,
    "data": [
      {
        "url": "https://example.com/images/canvas-bag.jpg",
        "alt": "Canvas bag"
      }
    ]
  },
  "bytes": {
    "requested": false,
    "success": null,
    "data": null
  },
  "parsed": {
    "type": "custom",
    "requested": false,
    "success": null,
    "data": null
  },
  "json": {
    "requested": false,
    "success": null,
    "data": null
  },
  "highlights": {
    "requested": false,
    "success": null,
    "data": null
  },
  "product": {
    "requested": false,
    "success": null,
    "data": null
  },
  "metadata": {
    "title": "Web context for AI",
    "language": "en"
  },
  "cache_metadata": {
    "status": "miss",
    "age_ms": 0
  },
  "request_id": "3f1c2a6e-8b4d-4c1e-9f0a-2d7b5e6c8a91"
}

Product image scraping at e-commerce scale

Collect product images across thousands of e-commerce sites for AI pipelines, visual search, and catalog enrichment.

Context.dev gives your pipeline one image extraction endpoint for public product and category pages across storefronts. Each request processes one page and returns the same JSON structure, so you can collect image URLs and metadata without maintaining a separate image parser for each store.

Build a bulk product-image pipeline

Discover and queue pages. Start with your catalog URLs or the Sitemap API. Deduplicate the URL list, limit concurrent requests, and save progress so a failed page does not restart the whole collection.
Extract and select images. Request dimensions and asset classification to filter candidates. Use wait controls or browser actions for dynamic galleries. Set maxAgeMs: 0 when a catalog refresh needs a fresh scrape.
Prepare the AI dataset. Download and validate selected images, retain the source page and collection date, and remove duplicates across stores. The API's dedupe option operates within each page. Follow the computer vision example to filter images before ingestion.

Handle blocking and rate limits at scale

Context.dev's managed scraping infrastructure handles JavaScript rendering, bot-detection bypass, and proxy escalation. If a target still blocks the scrape, a WEBSITE_BLOCKED response is not billed. Test representative storefronts before scaling; access and image coverage depend on the target.

Pace your queue using the rate-limit headers. Honor Retry-After on 429 responses and use bounded retries with backoff for temporary failures. Record persistently blocked pages for review while other jobs continue. Image downloads need their own failure handling because a returned URL can expire or reject a later fetch.

Base calls cost 1 credit. Calls with browser actions require a paid plan and cost 2 credits total. Image enrichment is included in both. Plan throughput using current pricing and the error-handling guide.

Compare Context.dev, Bright Data, and Oxylabs

For product images, compare the returned image fields and how bulk work reaches your pipeline. These products expose different collection and delivery workflows.

Scroll sideways to see the image and bulk workflows.

Context.dev, Bright Data, and Oxylabs for bulk product image extraction
API	Image workflow	Bulk workflow
Context.devImage Scraper API	One image schema across page URLs, with alt text and optional dimensions, classification, and visual deduplication.	Queue one request per page within your plan limits. Your pipeline manages URL discovery, checkpoints, and dataset storage.
Bright DataWeb Scraper API	Dedicated e-commerce scrapers return product records with image fields on supported targets, such as Amazon. Fields depend on the scraper.	Supports asynchronous collections, with completed results retrieved as snapshots and options for delivery to your storage.
OxylabsWeb Scraper API	Use a supported product parser or configure Custom Parser for the image fields you need. Browser instructions support dynamic pages.	Supports batches of up to 5,000 URLs or queries, asynchronous jobs, and cloud storage delivery.

Start with Context.dev when you have page URLs and want a consistent image inventory across storefronts. Evaluate Bright Data or Oxylabs when their dedicated product parsers or managed batch delivery fit your requirements. Compare usable images, resolution, completed-page cost, and throughput on the same sample of sites.

Sources: the product documentation linked above, Bright Data snapshot delivery, and Oxylabs batch queries. Checked September 14, 2026.

Website image scraper comparison

Comparing image extractor tools for developers in 2026 starts with the job: extracting a known page, crawling a site, or discovering images through search.

Context.dev is a direct fit when your application has page URLs and needs a consistent image response, including from JavaScript-rendered pages. Apify offers a marketplace of specialized Actors. The two below handle different discovery workflows, so compare the specific Actor with your requirements.

Scroll sideways to compare all three tools.

Context.dev compared with Apify Website Image/Media Extractor and Google Images Scraper
Compare by	Context.devImage Scraper API	Apify Website Image/Media ExtractorBy Logiover	Apify Google Images ScraperBy Hooli
Starting input	A webpage URL	Website start URLs and a crawl limit	Google Images search queries
Page coverage	One page per request; you supply the URL list	Follows internal links across a website	Search results with links to source pages
JavaScript content	Browser rendering, wait controls, and optional browser actions	Parses server-rendered HTML; does not execute JavaScript	Collects results from Google Images
Image output	URLs, inline SVGs, base64, responsive sources, CSS backgrounds, and posters	Image, video, and audio URLs, including responsive and CSS sources	Image URLs, thumbnails, and source page URLs
Metadata	Image URLs and alt text; optional dimensions and asset classification	Alt text, source pages, and media attributes	Page titles and image / thumbnail dimensions
Integration	Unified REST endpoint with a consistent image schema	Apify Console or Actor API, with dataset exports	Apify Console or Actor API, with dataset exports

Sources: the API reference and Actor documentation linked above, checked September 11, 2026. These are specific Actors; other Apify tools have different capabilities. For a site-wide media inventory, evaluate the website Actor. For keyword-based image discovery, evaluate the Google Images Actor.

Image scraping workflows

Load dynamic galleries and prepare the images your computer vision pipeline needs.

Extract images from JavaScript-heavy websites

A gallery may insert images after the initial HTML arrives. Use sharedParams.waitFor with a selector or delay to allow that content to load before extraction. Set an overall deadline with timeoutOpts.milliseconds that leaves time for rendering and processing.

Images triggered by scrolling, pagination, or clicks may need browser actions. Actions require a paid plan. Check the resulting images; a timed wait alone cannot guarantee that every item in an infinite gallery loads.

Collect images for computer vision training datasets

Request resolution and classification enrichment to filter images by measured dimensions and asset type. This example fetches a fresh page, waits two seconds, deduplicates its images, and selects photographs measuring at least 512 pixels in each dimension.

TypeScript

const response = await fetch("https://api.context.dev/v1/web/scrape", {
  method: 'POST',
  headers: {
    Authorization: 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "url": "https://example.com/gallery",
    "formats": {
      "images": true
    },
    "sharedParams": {
      "waitFor": 2000
    },
    "timeoutOpts": {
      "milliseconds": 30000
    },
    "maxAgeMs": 0,
    "imageParams": {
      "dedupe": "visual",
      "enrich": [
        "dimensions",
        "classification"
      ]
    }
  }),
});

if (!response.ok) throw new Error(await response.text());
const data = await response.json();
const candidates = data.images.data
  .filter((image) => image.classification === 'photography' && image.width >= 512 && image.height >= 512)
  .map((image) => ({ sourcePage: data.url, imageUrl: image.url, alt: image.alt }));

console.log(candidates);

Image enrichment uses imageParams.enrich and is included in the unified scrape base cost. Metadata can be missing when an image cannot be processed, so the example excludes unmeasured or unclassified images. The available resolution comes from the source website; extraction does not create a higher-resolution original.

Download the selected URLs, validate the files, and retain the source page, collection date, and usage rights with your dataset records. Review alt text before using it as a label, and deduplicate across pages before creating training and evaluation splits.

Frequently asked questions

Explore the web scraping API, check pricing and rate limits, or download every image from one page with the free image extractor.

How do I extract all images from a website?

Send POST /v1/web/scrape with url and formats: { images: true }. Read the image list from images.data. Use Map URLs to discover page URLs, then scrape each page to cover a website.

What image formats and HTML sources are supported?

The Scrape API discovers page images including responsive sources, CSS backgrounds, metadata images, and inline assets. Each entry has a url containing an HTTP URL or an image data URI, plus alt text when available.

Can I download all the extracted images?

Download HTTP image URLs with an HTTP client, or decode image data URIs. Request imageParams.enrich: ["file"] for a hosted fileUrl when processing succeeds and zero data retention is disabled. Hosted copies are valid for 24 hours from the original capture. The API does not return a ZIP archive.

Can I scrape product images from thousands of e-commerce sites for an AI pipeline?

Yes. Build a URL list from your catalogs or sitemaps, then queue one image extraction request per public product or category page. Context.dev returns the same image schema across sites. Pace requests to your plan limits, save progress and source URLs, and download and validate the selected images. Optional dimensions and classification help filter candidates; deduplicate across pages in your own pipeline.

Can I use an image scraping API for computer vision training datasets?

Yes, as the collection stage of a dataset pipeline. Extract images and source metadata, request resolution and classification enrichment, and filter candidates by dimensions and asset type. Then download and validate the files, review labels and usage rights, and remove duplicates across the dataset before training.

How does Context.dev compare with Bright Data and Oxylabs for product images?

Context.dev focuses on a consistent page image inventory with optional dimensions, classification, and deduplication. You queue one request per page. Bright Data offers dedicated e-commerce scrapers with product image fields and asynchronous snapshot delivery. Oxylabs offers supported product parsers, custom parsing, browser controls, and batch queries. Choose based on whether you need image metadata across storefronts or a provider-specific product schema and managed bulk delivery.

Am I billed for failed requests?

No. Failed requests and requests blocked by the target are not billed. Credits are consumed on successful responses.

Can I scrape images from JavaScript-heavy websites?

Yes. Use sharedParams.waitFor with a selector or a delay to wait for content before collecting images. For content that needs scrolling or clicks, configure sharedParams.actions on a paid plan. Coverage depends on the page state reached.

Does the image extractor return alt text?

Yes. Each image includes alt text from the source when available, otherwise null. This supports accessibility audits and image search indexing. Alt text is source content, so review it before treating it as a computer vision label or a verified caption.

Can I extract full-resolution product images?

The available resolution depends on the source website. Request imageParams.enrich: ["dimensions"] for width and height, then filter suitable images. Set imageParams.dedupe to visual to group visual duplicates. Extraction does not upscale images or guarantee access to an original file.

How does Context.dev handle blocked requests during bulk image scraping?

Context.dev manages JavaScript rendering, bot-detection bypass, and proxy escalation. Access is still target-dependent: a WEBSITE_BLOCKED scrape response is not billed. Honor Retry-After on 429 rate-limit responses, use bounded retries for temporary failures, and record persistently blocked pages for review. Test a representative sample of storefronts before scaling your collection.

How does Context.dev compare with Apify image scrapers?

Context.dev provides a page image extraction endpoint with a consistent response schema. Apify offers specialized Actors: Website Image/Media Extractor by Logiover crawls media in server-rendered HTML, while Google Images Scraper by Hooli collects search results. Choose based on whether you have page URLs, need a site-wide media inventory, or want keyword-based image discovery.

Is the image scraper API free to try, and how are calls priced?

The free tier includes 1,000 credits per month. A unified scrape costs 1 credit across selected formats, or 2 credits with browser actions. Image enrichment has no separate 5-credit charge in the unified API. See pricing for plan allowances and optional OCR charges.