Summarize a web page
Skip the part where you write a scraper just to get plain text out of a page. This URL summarizer API takes a link, fetches and cleans the page itself, and returns a summary of what's actually on it — one call instead of a fetch-parse-strip-summarize pipeline you'd otherwise maintain yourself.
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.
Built for when your input is a link, not a document
A huge amount of the text worth summarizing doesn't arrive as a clean string — it arrives as a URL: a news article, a competitor's blog post, a shared link in a customer message, a product page a research tool needs to understand. Handling that normally means fetching the page, stripping navigation and ads, isolating the article body, and only then summarizing — four separate failure points before the actual work even starts. This endpoint collapses that into one request.
What happens after you send the link
Call POST /text/summarize-url with the target URL and you get a task_id back immediately. Behind the scenes, we retrieve the page, extract its readable content, and run the summarization — all as one asynchronous task, since fetching a live page adds real network variability that has no place blocking your application. The result reaches you through your signed webhook or a signed link valid for 24 hours, whichever fits your workflow.
Why summarizing pages is harder than summarizing text
The web wasn't built as a text corpus — it was built as a layout medium, and most pages bury their actual content inside menus, related-article widgets, comment sections and ad slots that have nothing to do with the substance a reader came for. Reliable web-content extraction has been its own quiet discipline since the early days of 'reader mode' browser features, and it's the part of this endpoint that does the real work before summarization ever begins.
Common places this slots in
Newsroom and content tools use it to generate a summary the moment an editor pastes in a source link. Competitive-intelligence workflows use it to digest a competitor's announcement page without a human opening the tab. Chat and support tools use it to explain what a link a customer just shared actually contains. In each case, the calling application never has to know or care how page-fetching and extraction work — it just gets a summary back.
What it costs
Pricing has a flat fee per request plus a per-URL rate, both published up front — no hidden charge for the fetch step. If the page can't be retrieved or summarization otherwise fails, the task is retried automatically up to three times, and a task that ultimately fails is never billed; you only pay when a real summary comes back.
What you can do with it
Editorial and content curation
Paste a source article's URL and get a summary an editor can review in seconds before deciding to cover the story.
Competitive intelligence
Summarize a competitor's product or pricing page automatically whenever a monitoring tool detects it changed.
Chat and support link previews
Explain what a URL a customer shared actually says, without an agent having to open and read the page.
Research and bookmarking tools
Attach an automatic summary to every link a user saves, so a reading list is scannable without opening each tab.
FAQ
How does the URL summarizer API handle the page fetch?
It retrieves the page and extracts the readable content itself, so you send a plain link and never write scraping or parsing code.
Is there a free way to try the URL summarization 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.
What happens if the URL requires a login or is blocked to bots?
Pages behind authentication or aggressive bot protection may not be retrievable; in that case the task fails cleanly and, after retries, is never charged.
Can I summarize a PDF or non-HTML link?
The endpoint targets standard web pages; for raw documents, send the extracted text to the plain text summarization endpoint instead.
How do I get the summary back?
Provide a webhook URL to be notified once it's ready, or retrieve it from the signed result link, valid for 24 hours after completion.
What if the request fails?
It's retried automatically up to three times, whether the failure is the fetch or the summarization step; failed tasks are never billed.
Can I submit many URLs in bulk?
Yes, each URL is its own async task, so you can submit a batch in parallel and collect each summary as its webhook arrives.
How is this different from just pasting the article text into the summarizer?
This endpoint does the fetching and content extraction for you; if you already have clean text, the plain text summarization endpoint is the simpler and cheaper choice.
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, and soon from our app, email and Telegram.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/text/summarize-url \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"url":"https://ejemplo.com"}'const res = await fetch("https://api.kit.forhosting.com/text/summarize-url", {
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/text/summarize-url",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"url": "https://ejemplo.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/summarize-url", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"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/text/summarize-url", 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": "text.summarize_url",
"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
max_tokens | 20000 |
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. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |