ForHosting KIT · OCR & Data Extraction

Screenshot to text

Somebody sends you a screenshot of an error message, a chat thread or a settings screen and the only way to act on it used to be retyping every word by hand. This endpoint reads that screenshot and gives back the actual text, so whatever was trapped inside a bitmap becomes something you can search, copy or feed into another system.

● StablePer request + per image$0.010

Run — $0.010 + $0.0575/image 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.

The gap between seeing text and having it

A screenshot is a picture, and pictures don't have a clipboard. Support tickets arrive as a screenshot of an error dialog, bug reports include a capture of a stack trace, and product feedback shows up as an image of a settings panel with a complaint circled around it. In every one of those cases a person is currently retyping text that already existed on someone else's screen, and this endpoint exists to remove that step.

What it's tuned to handle

Unlike a scanned document, a screenshot contains UI chrome: menu bars, buttons, chat bubbles, code editors with syntax highlighting, terminal output, notification banners. The endpoint is built to separate the actual text content from that visual noise and return it in reading order, so a chat screenshot comes back as a conversation, not as scrambled fragments of avatar names and timestamps mixed with message text.

From pixels to something you can grep

Screen text is usually rendered cleanly by the operating system rather than photographed at an angle, which works in the endpoint's favor: fonts are crisp, contrast is consistent, and there's no lens distortion to correct for. That means the harder cases tend to be about density and layout, like a cluttered dashboard with a dozen small labels, rather than about legibility.

How the request is handled

Submit the image to POST /ocr/screenshot and you receive a task_id immediately while the extraction runs asynchronously. Results are delivered to your signed webhook or fetched from a signed link valid for 24 hours, and if a screenshot genuinely can't be parsed after three internal attempts, you get a clear error and no charge.

Where this saves the most time

Support teams use it to turn a customer's error screenshot into searchable text they can match against a known-issues database, QA pipelines feed automated test-failure captures through it to extract the exact error string, and content teams pull quotes or captions out of screenshots shared in Slack without ever opening an image editor.

What you can do with it

Support ticket triage

A helpdesk extracts the exact error text from a customer's screenshot and matches it automatically against a known-issues list instead of a human reading the image.

Bug report processing

A QA pipeline pulls the stack trace text out of an automated test-failure screenshot so it can be logged and deduplicated as plain text.

Archiving chat conversations

A compliance team converts a screenshot of a chat thread shared as evidence into searchable transcript text.

Pulling quotes from shared images

A content editor extracts a caption or comment from a screenshot circulating in a group chat without retyping it by hand.

FAQ

What does a screenshot to text API do?

It reads any screen capture, including UI elements, chat messages, code or error dialogs, and returns the visible text as copyable, structured content.

Is there a free way to try it?

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 each screenshot cost?

$0.010 per request plus $0.0575 per image, charged only for tasks that complete successfully.

Does it handle code and terminal screenshots?

Yes, it's built to separate real text content from UI chrome, so code editors, terminals and syntax-highlighted panes extract cleanly.

Is screenshot text extraction more accurate than photo OCR?

Generally yes, because screen-rendered text is crisp and undistorted compared to a photographed document, though very dense or cluttered layouts can still be harder to parse.

How do I retrieve the extracted text?

Call POST /ocr/screenshot to get a task_id right away, then receive the result via a signed webhook or a signed link valid for 24 hours.

What if the screenshot is too small or low resolution?

The system retries internally up to three times; if it still can't extract reliable text, you get a clear error and are not charged.

Can I process a batch of screenshots?

Yes, each screenshot runs as its own asynchronous task, so you can submit a batch and collect results as they finish.

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/ocr/screenshot

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/ocr/screenshot \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"image":"https://ejemplo.com/imagen.jpg"}'

const res = await fetch("https://api.kit.forhosting.com/ocr/screenshot", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "image": "https://ejemplo.com/imagen.jpg"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/ocr/screenshot",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "image": "https://ejemplo.com/imagen.jpg"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/ocr/screenshot", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"image":"https://ejemplo.com/imagen.jpg"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"image":"https://ejemplo.com/imagen.jpg"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ocr/screenshot", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "image": "https://ejemplo.com/imagen.jpg"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "ocr.screenshot",
  "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.010

Per image$0.0575

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	25
`max_pages`	10

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 →