Is my input uploaded anywhere?

No. Parsing runs in your browser. Nothing is sent to Irmu's servers, nothing is stored and nothing is logged. Image previews are loaded directly from their original host by your browser.

Which image URLs does it find?

In HTML: img src, srcset and picture sources, lazy-loading attributes such as data-src and data-original, SVG image href, input type=image, CSS url() in style attributes and style blocks, Open Graph and Twitter image meta tags, favicons and apple-touch icons, and image fields inside JSON-LD. In Markdown: image syntax, reference definitions and inline HTML. In plain code or text: quoted paths with an image extension, CSS url() values and bare URLs.

How do relative paths become full URLs?

Set a base URL and every relative path — /assets/hero.png, ../img/photo.jpg — is resolved against it. Without a base URL, relative paths are skipped because there is no way to know where they point.

Can I get every srcset variant?

Yes. With the srcset toggle on, each candidate in a srcset or data-srcset is returned as its own row, with the width or density descriptor kept in the width column of the CSV and JSON export.

Does it handle base64 data URIs?

They are skipped by default because they bloat the list. Turn on 'Data URIs' to include inline data:image/... values as their own rows.

What is in the CSV export?

One row per image with the absolute URL, filename, extension, domain, alt text, srcset descriptor and where in the document it was found. It is RFC 4180 quoted, so it opens cleanly in Sheets and Excel.

Image URL extractor — pull image links from HTML, Markdown or code

Code examples

Do the same thing in your own pipeline

The tool above parses in the browser. Here is the equivalent image extraction with the standard HTML parser in each language.

# pip install beautifulsoup4

import re
from urllib.parse import urljoin
from bs4 import BeautifulSoup

IMAGE_EXT = re.compile(r"\.(jpe?g|png|gif|webp|avif|svg|bmp|ico|tiff?)($|\?)", re.I)

def extract_image_urls(html: str, base: str) -> list[str]:
    soup = BeautifulSoup(html, "html.parser")
    found: list[str] = []

    for img in soup.find_all("img"):
        for attr in ("src", "data-src", "data-original", "data-lazy-src"):
            if img.get(attr):
                found.append(img[attr])
        for srcset in (img.get("srcset"), img.get("data-srcset")):
            if srcset:
                found += [part.strip().split(" ")[0] for part in srcset.split(",") if part.strip()]

    for source in soup.select("picture source[srcset]"):
        found += [part.strip().split(" ")[0] for part in source["srcset"].split(",") if part.strip()]

    for meta in soup.select('meta[property*="image"], meta[name*="image"]'):
        if meta.get("content"):
            found.append(meta["content"])

    for el in soup.select("[style]"):
        found += re.findall(r"url\(\s*['\"]?([^'\")]+)", el["style"])

    seen, out = set(), []
    for value in found:
        url = urljoin(base, value.strip())
        if not url.startswith("http") or not IMAGE_EXT.search(url):
            continue
        if url not in seen:
            seen.add(url)
            out.append(url)
    return out

html = '<img src="/assets/hero.png" alt="Hero"><img data-src="https://cdn.example.com/a.webp">'
for url in extract_image_urls(html, "https://example.com/"):
    print(url)

How it works

Where image URLs actually hide

img src plus the lazy-loading attributes real sites use — data-src, data-original, data-lazy-src.
Every candidate inside srcset, data-srcset and picture sources, with its width or density descriptor kept.
CSS backgrounds: url() values in style attributes and inline style blocks.
Social and structured data: Open Graph and Twitter image tags, favicons, apple-touch icons and image fields in JSON-LD.
Anything else: quoted image paths in JSON, JS or CSS, Markdown image syntax and bare URLs in plain text.
Relative paths resolved against your base URL, deduplicated, filtered by format and domain, then exported.

With Irmu

When you also need to fetch the page

Most product galleries only appear after JavaScript runs. Irmu renders the page and returns the final HTML — extract the images from that.

crawl_to_images.py

# pip install requests beautifulsoup4

import csv, os, requests
from urllib.parse import urljoin
from bs4 import BeautifulSoup

target = "https://example.com/products/widget"

# Irmu fetches the page: rendering, proxies, retries and anti-bot handling included.
resp = requests.get(
    "https://app.irmu.com/api/crawl",
    headers={"Authorization": f"Bearer {os.environ['IRMU_API_KEY']}"},
    params={"url": target, "js": "true", "premium": "true", "wait_until": "networkidle2"},
    timeout=90,
)
resp.raise_for_status()

soup = BeautifulSoup(resp.text, "html.parser")

images = []
for img in soup.find_all("img"):
    src = img.get("src") or img.get("data-src")
    if src:
        images.append({"url": urljoin(target, src), "alt": img.get("alt", "")})

with open("images.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["url", "alt"])
    writer.writeheader()
    writer.writerows(images)

print(f"{len(images)} images from {target}")

download_images.mjs

// Node 18+ — download every image URL you extracted
import { writeFile, mkdir } from "node:fs/promises";
import { basename } from "node:path";

const urls = JSON.parse(await (await import("node:fs/promises")).readFile("image-urls.json", "utf8"))
  .map((row) => row.url);

await mkdir("images", { recursive: true });

for (const url of urls) {
  const res = await fetch(url, { headers: { "User-Agent": "Mozilla/5.0" } });
  if (!res.ok) {
    console.warn("skip", url, res.status);
    continue;
  }
  const buffer = Buffer.from(await res.arrayBuffer());
  await writeFile(`images/${basename(new URL(url).pathname) || "image"}`, buffer);
}

Image URL extractor

Do the same thing in your own pipeline

Where image URLs actually hide

When you also need to fetch the page

Questions about this tool

Turn any URL into clean image data