ForHosting KIT · Images

Add text to an image

A product photo without a price sticker, a banner without a headline, a thumbnail without a caption — all of them are unfinished until text lands on the pixels. This endpoint places one or more strings of text onto an image at the position, size and color you specify, and hands back a finished file instead of a half-built one.

● StablePer request + per image$0.002

Run — $0.002 + $0.005/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 a photo and a finished asset

A raw photo and a marketing-ready image are separated by a handful of design decisions that are trivial for a person and tedious to automate: where does the price go, how big is the headline, does the text need a background box to stay readable over a busy photo. This endpoint takes those decisions as parameters — text, position, font size, color, optional background — and applies them the same way every time, which matters far more than it sounds once you're doing it a thousand times a day.

Who is placing text on images at scale

Marketplaces stamping a price or a 'sold' badge across every listing photo, e-commerce teams generating a batch of promotional banners from one template and a spreadsheet of headlines, social media schedulers burning a quote or a caption onto a background image before it posts, real estate platforms adding a status label like 'available' or 'under contract' to every property photo.

What actually happens to the file

You submit the source image plus the text and its placement, receive a task_id right away, and the job renders the text directly into the image — not as a separate layer, but baked into the pixels — so the file that comes back is ready to publish as-is, with no design software involved.

Where it sits in a bigger pipeline

Because each call is billed per image and returns asynchronously, it slots naturally after an image is uploaded or generated and before it's published: a listing gets photographed, the price is overlaid automatically, and the finished image moves straight to the storefront without a human opening an editor in between.

A small operation with outsized leverage

Overlaying text is one of the oldest tricks in image editing — it predates digital tools entirely, going back to hand-lettered signage and darkroom printing — but doing it correctly and consistently across thousands of images a day is a different problem than doing it once well in an editor, and that's the gap this endpoint closes, quietly, request after request, without anyone re-checking alignment by eye.

What you can do with it

Marketplace price stamping

A listings platform overlays the current price onto every product photo the moment a seller updates it, keeping images in sync with inventory.

Batch promotional banners

A marketing team generates a week's worth of social banners from one background template and a spreadsheet of headlines and dates.

Real estate status labels

A property site stamps 'Available', 'Sold' or 'Under Contract' across listing photos automatically as status changes.

Quote and caption graphics

A content scheduler burns a daily quote onto a background image before it's queued for posting, with no manual design step.

FAQ

How do I add text to an image with this API?

Send a POST to /image/text-overlay with the source image and the text plus its position, size and color; you get a task_id and the finished image comes back by webhook or signed link.

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.

How is it priced?

$0.002 per request plus $0.005 per image, published and flat regardless of how much text is placed.

Can I add more than one line of text?

Yes, multiple text elements can be placed on the same image in a single call, each with its own position and styling.

Which image formats are supported?

Common raster formats such as JPEG and PNG are accepted, and the output preserves the format and dimensions of the source image.

Can I control the font, size and color?

Yes, font size, color and an optional background box are all parameters you set per text element for full control over the result.

Am I charged if the overlay fails?

No. A failed task is retried automatically up to three times and never billed; you get a clear error instead of a charge.

Can I process a batch of product photos at once?

Each call handles one image and returns its own task_id, so batching a thousand product photos is simply a thousand parallel requests collected by webhook.

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/image/text-overlay

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/image/text-overlay \
  -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/image/text-overlay", {
  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/image/text-overlay",
    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/image/text-overlay", 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/image/text-overlay", 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": "image.text_overlay",
  "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

Per image$0.005

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

Limits

`max_mb`	15
`max_megapixels`	12

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 →