ForHosting KIT · Text & AI

Generate text

The text generation API takes a prompt and returns written text, queued behind a job system instead of a live stream — which means your invoice can be predicted in advance rather than discovered after the fact. There is no token meter to watch; you are billed per request plus a flat rate per 1,000 words produced.

● StablePer request + per 1,000 words$0.003

Run — $0.003 + $0.0135/1,000 words 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 put an LLM behind a queue

Most text-generation integrations are built for a chat window, where a person is staring at the screen waiting for words to stream in. A lot of real generation work — product copy at scale, report drafting, batch content for a CMS — has no one watching in real time, and forcing that work through a synchronous, streaming API just adds fragile connection-handling code for no benefit. This endpoint is built for the batch case: send the prompt, walk away, get the text when it is ready.

What sending a request actually looks like

A call to POST /text/generate with your prompt returns a task_id right away and queues the generation job. The finished text is delivered later through a signed webhook, which is the recommended route for anything automated, or through a signed link that stays valid for 24 hours if you would rather poll or hand a link to someone. Neither delivery method requires you to keep a socket open.

On pricing you can actually predict

Token-based pricing from most language-model providers is notoriously hard to estimate before a call finishes, because tokenization varies by content and language. This endpoint prices in request count and words instead: $0.003 per request plus $0.0135 per 1,000 words generated, so a batch of 500 prompts targeting roughly 300 words each has a cost you can compute on a spreadsheet before you ever call the API.

Where it fits in a larger system

Because the interface is a queue rather than a stream, text generation here composes cleanly with other async endpoints — feed a document Q&A result into a generation prompt, or chain generated text into a formatting or translation task, without ever needing to hold a request open across multiple model calls. Retries and failures are handled the same way across every endpoint, so your error handling stays uniform.

What to expect from output and limits

Longer prompts and longer requested outputs take proportionally longer to clear the queue; there is no artificial cap dressed up as a feature, just the honest tradeoff between length and wait time. Access requires prepaid balance rather than a free tier, which keeps the queue free of throwaway abuse traffic, and a task that fails after three retries returns a clear error and is never billed.

What you can do with it

Overnight content batches

A CMS queues a week's worth of newsletter drafts before end of day and lets the webhooks fill the editorial calendar by morning.

Report drafting from structured data

A reporting tool turns a JSON summary of monthly metrics into a written narrative section, run automatically at the start of each reporting cycle.

Prompt chaining in a pipeline

A workflow generates an outline, waits for the webhook, then feeds each section back through the endpoint to expand it — all without a person in the loop.

Cost-predictable content scaling

A marketing team forecasts monthly spend for a content push by multiplying planned word counts against the published per-word rate, before writing a single prompt.

FAQ

How does the text generation API work?

You send a prompt to POST /text/generate, it is queued as an async task, and the generated text is delivered by signed webhook or a signed link valid for 24 hours.

Is there a free trial for the text generation 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.

How is pricing calculated — is it per token?

No tokens: pricing is $0.003 per request plus $0.0135 per 1,000 words of generated text, a rate you can calculate in advance.

Why is the API asynchronous instead of streaming?

Streaming assumes someone is watching live; this endpoint targets batch and pipeline use, so it queues the job and delivers the finished result by webhook instead.

What happens if a generation task fails?

The task retries automatically up to three times; if it still fails you get a clear error and are never charged.

Can I use this for bulk content generation?

Yes — queue as many requests as you need in parallel; each returns its own task_id, which is what the endpoint is designed for.

How long is generated text available after completion?

The signed link stays valid for 24 hours, after which the result is deleted and never used for training.

How does this compare to a chat-style completion API?

A chat API is built for a live back-and-forth; this one is built for unattended batch generation with predictable, non-token-based pricing.

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

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/generate \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"text":"…"}'

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

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/text/generate",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "text": "…"
},
)
task_id = res.json()["task_id"]

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

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

Example request

{
  "text": "…"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "text.generate",
  "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.003

Per 1,000 words$0.0135

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.

Read the full KIT documentation →