ForHosting KIT · Developer Utilities

Generate a README

Most README files are either missing, three years stale, or copy-pasted from a template that never matched the code. This endpoint actually reads your repository — its structure, dependencies, entry points — and drafts a README that describes the project you shipped, not the one a boilerplate assumed.

● BetaPer request + per repo$0.003

Run — $0.003 + $0.0135/repo 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 code and documentation

Documentation debt accrues quietly. A team ships features for months, the package.json grows new scripts, a config file changes its defaults, and the README still says the project uses a build tool nobody has run in a year. New contributors clone the repo, follow instructions that no longer apply, and either give up or ping someone in chat. dev.readme targets exactly that moment: a repository that works but explains itself poorly.

What the endpoint actually inspects

Send POST /dev/readme with a reference to the repository, and the task reads what's really there: manifest files for the language and dependencies, the directory layout for likely entry points, existing scripts for how the project builds, tests and runs, and any license or config files that describe intent. It does not invent a tech stack or guess at features from the project name — it drafts from what the code and its metadata actually show, then organizes that into a structured README with installation, usage and relevant sections.

Async by design, delivered when it's ready

The call returns a task_id immediately, because reading a repository, especially a large one, takes real time — you get the draft back through a signed webhook call or a signed link valid for 24 hours, whichever your pipeline already listens for. There's no polling loop to write and no risk of a slow repository blocking a request thread.

Where it fits an automated workflow

Teams that generate scaffolding, forks, or internal service repositories on a schedule end up with dozens of near-identical projects that each need a README nobody wants to write by hand. Wiring this endpoint into that same automation means every new repository gets a real, current README the moment it's created, priced per request plus per repository processed, and a failed attempt costs nothing because it's retried automatically before it's ever charged.

A short history worth remembering

The README convention itself dates back to early Unix source distributions, where a plain text file told a stranger how to build and run software before any package manager existed to do it for them. That original purpose — orient a stranger fast — is still the bar this endpoint writes to, decades and countless frameworks later.

What you can do with it

Freshly scaffolded microservices

A platform team generates a new service repository from a template every time a squad spins up a project, and this endpoint fills in the README with the service's actual dependencies and scripts instead of leaving the template's placeholder text.

Open-source onboarding

A maintainer inherits a repository with no documentation and runs it through this endpoint to get a first accurate draft, then edits from there instead of starting from a blank file.

Internal tooling at scale

An engineering org with hundreds of internal repositories batches this endpoint across all of them overnight so every tool has a baseline README, even ones nobody has touched in years.

Fork and template refresh

A company that forks a base repository for each client regenerates the README automatically after each fork so client-specific configuration is reflected instead of the original template's generic text.

FAQ

How does the README generator API work?

POST a reference to your repository to /dev/readme, keep the returned task_id, and collect the drafted README by webhook or a signed link valid for 24 hours.

Is the README generator API free?

No, there is no free tier or trial; it costs $0.003 per request plus $0.0135 per repository processed, and a failed task is never charged.

Does it actually read my code, or just guess from the repo name?

It reads manifest files, dependencies, directory structure and existing scripts to draft the README from what the repository actually contains.

Can it document a private repository?

Yes, as long as you provide a reference the task can access; the repository content is deleted after the retention window and never used for training.

Will it overwrite my existing README?

No, the endpoint returns a drafted README as a result; whether and how you apply it to the repository is entirely up to your own workflow.

Can I generate READMEs for many repositories in bulk?

Yes, submit one async task per repository and collect each result by webhook as it completes, which suits a batch or scheduled pipeline well.

What if the repository has almost no code yet?

The draft reflects what exists at the time of the request, so a very early repository will get a minimal but accurate README rather than a fabricated one.

Is this endpoint live?

Yes, /dev/readme is live and accepting requests now.

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/dev/readme

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

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

import os, requests

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

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

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

Example request

{
  "input": "…"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.readme",
  "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 repo$0.0135

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

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 →