ForHosting KIT · Web Scraping & Monitoring

Web page to text

Sometimes you don't want structure, links or formatting — you just want the words. This URL to text API renders a page and returns nothing but its readable prose, the plain sentences a person would read out loud if you stripped away every tag around them.

● StablePer request + per URL$0.040

Run — $0.040 + $0.001/URL 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.

When plain text beats every other format

Markdown keeps structure; HTML keeps everything. Plain text keeps neither, and that's exactly the point for tasks like keyword search indexes, sentiment analysis, language detection, or word counts, where headings and hyperlinks are noise rather than signal. Anyone building a pipeline that just needs 'what does this page say, in words' has been over-served by every richer format.

What the conversion actually strips

The page is rendered first so dynamically loaded content is captured, then everything that isn't prose gets removed: tags, attributes, inline scripts and styles, navigation chrome, and formatting marks that Markdown or HTML would have kept. What remains is continuous readable text — paragraphs in order, without markup characters interrupting the flow a text-processing tool expects.

A format with no ambition, on purpose

Plain text is the oldest interchange format in computing, older than the web itself, and it has survived because it demands nothing of the tool reading it — no parser for tags, no encoding surprises beyond character set. Reducing a modern, JavaScript-heavy page back down to plain text is a deliberate downgrade: you're trading every visual and structural cue for a format that any script, however simple, can consume without a library.

Why this differs from the Markdown converter

The sibling Markdown endpoint keeps headings, lists and links because some downstream use wants that structure back. This one assumes you don't — that whatever consumes the output either doesn't care about structure or will impose its own. If you're unsure which you need, ask whether your next step re-parses formatting; if not, plain text is the smaller, simpler answer.

Fitting into an automated flow

Because results arrive by webhook or a signed 24-hour link, a text-extraction step composes cleanly with whatever comes after it — a classifier, a search indexer, a translation call, a duplicate-detection job. No intermediate HTML file to clean up, no Markdown to strip again if your downstream tool wanted text all along.

What you can do with it

Search indexing

Feed plain page text into a search index instead of parsing HTML at index time for every document.

Sentiment and NLP pipelines

Extract readable text from review or news pages before running sentiment analysis or entity extraction on it.

Duplicate and plagiarism checks

Compare the plain text of two URLs to spot copied content without formatting differences causing false negatives.

Translation preprocessing

Strip a page to text first, then send that clean prose to the translation endpoint instead of translating markup by mistake.

FAQ

How is this different from the Markdown converter?

Markdown keeps headings, lists and links; this endpoint keeps only the prose, with no structural markers at all.

Does it render JavaScript first?

Yes, the page is rendered before extraction so text built by client-side frameworks is included, not just the raw HTML response.

Will navigation and ads show up in the text?

No, boilerplate like menus, footers and ad blocks is excluded so the output is just the page's readable content.

Is there a free trial?

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 does it cost?

$0.040 per request plus $0.001 per URL, published and the same regardless of how long the extracted text turns out to be.

Can I submit several URLs at once?

Yes, a single request can include multiple URLs, each billed at the published per-URL rate.

What if extraction fails on a page?

It retries automatically up to three times; a run that still fails returns a clear error and is never charged.

How do I receive the text?

By signed webhook once the task completes, or a signed link valid for 24 hours if you prefer to fetch it directly.

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/to-text

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/to-text \
  -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/to-text", {
  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/to-text",
    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/to-text", 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/to-text", 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.to_text",
  "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.040

Per URL$0.001

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.
`422`	`task_failed`	The task failed after 3 retries. You are never charged for it.

Read the full KIT documentation →