Extract images
A page has forty images and you need to know which ones lack a description: paste its address and get each image with its full address and alt text exactly as written, empty ones included. You pay per page, with no subscription.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
list every image with its alt text
Why alt text still matters on every image
Alt text has been part of web pages since the earliest days. It was first meant for text-only browsers, and today it does several jobs at once: screen readers read it aloud, image search uses it to understand a photo, and visitors on a slow connection see it when the picture fails to load. A product photo with a blank description is a common reason it never shows up in image search. Telling apart an image with no alt text and a decorative one left empty on purpose matters, because the first is a gap to fix and the second is a deliberate choice.
Why checking images by hand goes wrong
Opening the developer tools and scrolling through the source works for one image, not for a page with forty. Simple text searches also miss images, because real pages tuck them inside fallback blocks for visitors without scripts, delay their loading until they scroll into view, or swap the picture depending on screen size. A complete list helps before a redesign, so nothing gets lost when a legacy page is rebuilt on a new system. It works just as well on a page you inherited from a previous team as on one you built yourself.
A quick word on the alt attribute
Alt text has been part of HTML since the earliest specification, originally meant for text-only browsers and now doing double duty for screen readers, image search indexing and slow connections that fail to load the image itself. Auditing it at scale is tedious by hand and easy to get wrong with a naive regex, since real-world markup nests images inside noscript tags, lazy-load attributes and picture elements that swap sources depending on screen size.
What you can do with it
Content migration checklists
Get a definitive list of image sources on a legacy page so nothing gets dropped when the page is rebuilt on a new CMS.
SEO image coverage
Check which product pages still have images with blank alt text, a common reason product photos never show up in image search.
Broken media monitoring
Combine the extracted src list with periodic checks to catch images that quietly started returning a 404 after a CDN change.
FAQ
Does it capture images loaded by JavaScript?
It reads the raw HTML exactly as the server returns it and does not run JavaScript, so images a client-side script injects only after the page loads aren't captured — every image tag present in the served HTML is.
What data is returned for each image?
Each entry includes the absolute image URL, the alt attribute as written (including empty), and width/height when the tag itself declares them.
Is the extracted data stored long-term?
No. Results are kept only for the retention window needed for delivery and are then deleted; nothing is used for training.
How does it treat an image whose alt text is empty on purpose?
It is listed with its empty alt text instead of being dropped, because an image with no alt text at all and a decorative image left empty on purpose mean very different things for accessibility.
Can the image list help me catch pictures that stop loading?
Yes. Keep the list of image addresses and check them regularly, and you will notice images that quietly started returning a 404 after a change in how your site delivers its files.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/images \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://example.com"}'const res = await fetch("https://api.kit.forhosting.com/web/images", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"url": "https://example.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/images",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://example.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/images", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"url":"https://example.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"url":"https://example.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/images", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"url": "https://example.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.images",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
timeout_sec | 30 |
max_crawl_pages | 25 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Point this endpoint at any public page and get back a clean inventory of every image on it: source, dimensions when available, and the alt text a screen reader or a search crawler would actually see. It's the fastest way to answer 'what images live on this page' without opening dev tools by hand.
Why teams pull an image list instead of scrolling
Content teams, accessibility auditors and SEO leads all hit the same wall: a page has forty images and nobody knows which ones are missing alt text until a screen reader user or a Lighthouse run complains. This endpoint turns that guesswork into a single structured answer, so you can catch the gaps before a customer does, and it works just as well on a page you inherited from a previous team as on one you built yourself.
What comes back
Decorative images with empty alt are flagged as such rather than silently dropped, because 'no alt' and 'empty alt on purpose' mean very different things for accessibility. Send a URL, get a task_id right away, then a webhook (or a signed link, valid 24 hours) with a list of every image found in the page's HTML: its absolute src, its alt attribute exactly as written including empty strings, and width/height when the tag itself declares them.
Where it fits in a pipeline
There's no need to poll anything manually; the results simply show up as each page finishes processing, in whatever order the pages happen to complete. Because the call is asynchronous, you can fan out hundreds of pages from a sitemap in one batch, let the webhook collect results as each finishes, and feed the output straight into an accessibility dashboard, a broken-image monitor, or a content migration script that needs to know exactly what media a page depends on before it's rewritten or retired.
Integration use cases
Accessibility audits before a launch
Run every page on a new site through the endpoint and flag any image with a missing or generic alt attribute before it goes live.
Technical questions
How do I extract images from a URL with this API?
Send a POST request to /web/images with the target URL; you get a task_id immediately and the full image list arrives by webhook or a signed link once the task finishes.
Is there a free tier for the image extraction API?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
How much does the image extraction endpoint cost?
It's $0.002 per request, a flat price per page regardless of how many images that page contains.
How do I get the results?
Choose a signed webhook for automatic delivery, or fetch the result from a signed link that stays valid for 24 hours.
Can I run this on pages that require login?
The endpoint fetches publicly accessible URLs; pages behind authentication walls are outside its scope.