Generate an FAQ
Most FAQ sections are written from a blank page and a guess at what people might ask. The FAQ Generator API reads content you already have — a product page, a policy, a set of docs — and extracts the questions it actually answers, paired with concise responses drawn from that same text, so the FAQ reflects what's genuinely documented rather than what someone assumed.
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 guessed FAQs and grounded ones
Writing an FAQ from scratch usually means guessing at customer questions, and guesses drift from what a product or policy actually says over time — someone adds a new pricing tier and the old FAQ quietly goes stale. This endpoint works the other direction: it starts from your source text and surfaces the questions that text is already positioned to answer, which keeps the FAQ tethered to what's true in the document instead of what a writer assumed six months ago.
What happens between the request and the result
You POST your source content to /text/faq. The task processes asynchronously, and the resulting list of question-and-answer pairs is delivered to your webhook or a signed link once it's ready. Each answer is grounded in the submitted text rather than invented, so the output can be checked against the source directly — useful when the FAQ is going to represent a policy or a paid product's terms.
Why FAQs are their own well-studied format
The FAQ as a document type predates the web — it comes from Usenet newsgroups in the 1980s, where long-running communities got tired of answering the same beginner questions and wrote them down once. That original purpose still holds: an FAQ exists to answer the handful of questions that come up again and again, phrased the way a real person would ask them, not the way a company would prefer to phrase them. This task is tuned to extract that kind of natural, frequently-asked phrasing rather than a corporate restatement of headings.
How it fits an ongoing content workflow
Because it's async and billed per call, teams typically run it whenever source content changes: a docs update triggers a fresh FAQ generation for the page it belongs to, or a support team regenerates FAQs quarterly against the current policy text. A failed generation is retried automatically up to three times and never charged, which matters when this runs unattended against dozens of pages on a schedule.
What to expect in the output
The result is a set of question-and-answer pairs, typically covering the range from the most obvious question a reader would have to the less obvious edge cases the source text happens to address. It won't invent policy that isn't in your text — if the source is silent on something, the FAQ will be too, which is the point: the output is only as complete as the material you give it.
What you can do with it
Product page FAQs
An e-commerce team generates an FAQ block for each product page directly from its specs and shipping policy text, keeping it in sync automatically.
Support documentation
A SaaS company runs its help center articles through the endpoint to build a searchable FAQ hub without manually re-reading every article.
Policy and terms pages
A legal or compliance team turns a long terms-of-service document into a plain-language FAQ that answers the questions users actually have.
Onboarding and internal wikis
An HR team converts an internal handbook into an FAQ new employees can search instead of reading the full document top to bottom.
FAQ
How do I generate an FAQ from my content with this API?
POST your source text to /text/faq; the task runs asynchronously and the question-and-answer pairs are delivered by webhook or a signed link.
Is there a free trial for the FAQ generator 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 much does FAQ generation cost?
$0.003 per request plus $0.0135 per 1,000 words of source content, charged only when the task completes successfully.
Does it make up answers that aren't in my content?
No, answers are grounded in the text you submit; if your content doesn't cover a topic, it won't appear as a question.
How many questions will it generate?
The count scales naturally with the length and range of your source content rather than a fixed number, so a longer document tends to surface more distinct questions.
Can I use it on long documents like a terms-of-service page?
Yes, pricing scales with word count, so long policy or documentation pages work well as source material.
What happens if the FAQ generation task fails?
It's retried automatically up to three times and you're never charged for a task that doesn't complete.
How and when do I receive the FAQ output?
Via a signed webhook, recommended for automated pipelines, or a signed link valid for 24 hours; source content is deleted after retention and never used for training.
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/faq \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"…"}'const res = await fetch("https://api.kit.forhosting.com/text/faq", {
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/faq",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/text/faq", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/text/faq", 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.faq",
"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. |