ForHosting KIT · Web Scraping & Monitoring

Extract images

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.

● StablePer request + per URL$0.002

Run — $0.002 How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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.

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

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 rendered markup: its absolute src, its alt attribute exactly as written including empty strings, and width/height when the tag or the file exposes them. 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.

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 JavaScript-rendered components, and picture elements that swap sources depending on screen size add yet another layer a simple script tends to miss entirely.

Where it fits in a pipeline

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. 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.

What you can do with it

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.

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

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.

Does it capture images loaded by JavaScript?

The page is rendered before extraction, so images injected by client-side scripts are picked up alongside the ones present in the raw HTML.

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 that information is available in the markup or file.

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.

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.

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

POSThttps://api.kit.forhosting.com/web/images

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, and soon from our app, email and Telegram.

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 &#39;{"url":"https://ejemplo.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://ejemplo.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[&#39;KIT_KEY']}"},
    json={
    "url": "https://ejemplo.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" => &#39;{"url":"https://ejemplo.com"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"url":"https://ejemplo.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://ejemplo.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

Per request$0.002

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.

Read the full KIT documentation →