Lines to numbered Markdown list
Turn a block of separate lines into a numbered Markdown list without editing every item by hand.
Run — free
Paste steps, requirements, agenda points, or any other line-based text, choose the first number when the sequence should continue from an earlier section, and receive valid ordered-list syntax ready to copy into documentation. The conversion is deterministic, keeps the original wording of every line, and normalizes pasted line endings so the same input produces the same Markdown across operating systems and automation environments.
Prepare one intended item on each line
Start with plain text in which every line represents one item in the finished ordered list. This works well for installation steps copied from notes, acceptance criteria exported from a planning tool, agenda topics, recipe directions, or short instructions drafted without formatting. The converter does not rewrite, summarize, reorder, or interpret the wording. It treats the line boundary as the item boundary and preserves the characters within each line, including leading spaces that may be meaningful in a technical example. Windows, classic Mac, and Unix line endings are normalized before processing, so pasted material behaves consistently. A completely empty or whitespace-only value is rejected because it cannot produce a useful list. Interior blank lines are retained as empty numbered items rather than silently discarded; this makes the transformation predictable and prevents an automation workflow from changing the number or position of later entries without notice. Remove unwanted blank lines before converting when you do not want them represented.
Choose where the numbering begins
The default first marker is `1.`, which is the conventional start for an independent Markdown ordered list. You can provide a positive integer in the `start` field when the new block continues a sequence from another section. If you start at 4, for example, the first three input lines receive `4.`, `5.`, and `6.`. Every marker is followed by a period and one space, the broadly supported ordered-list form used by Markdown renderers. The output includes both a complete `markdown` string for copying and a `numbered_lines` array for programs that need to inspect or route individual items. It also reports `line_count` and the effective `start`, which makes automated checks straightforward. The start value must be an integer within the documented range; decimals, numeric strings, zero, and negative numbers are rejected instead of being rounded or guessed. This strict contract keeps results identical between the browser runner, API clients, scripts, and test environments.
Use the result in documentation and automation
Copy the returned `markdown` value directly into a README, issue description, knowledge-base article, static-site source file, or any editor that accepts Markdown. Because the tool only adds ordered-list markers, review the result when an original line already begins with a bullet or number; those characters are part of your content and are deliberately preserved. In an automated workflow, send the source text and optional start number, then store or publish the returned string without needing a Markdown library. The operation uses no network requests, generative model, date, or random value, so repeated calls with identical input always return identical output. Browser use is convenient for an occasional formatting task, while API use costs $0.002 per request and suits documentation generators, release tooling, and content pipelines. Input size and line-count limits keep execution bounded. If a source exceeds them, split it into logical sections and set the start number for each later section to maintain the intended sequence.
What you can do with it
Format documentation steps
Turn an unformatted sequence of setup or troubleshooting lines into ordered Markdown ready for a README or support article.
Continue an existing procedure
Set a custom starting number when a new block of instructions follows steps that are maintained in another section.
Automate publishing workflows
Convert line-based output from another system into predictable Markdown before inserting it into generated documentation.
FAQ
What does the conversion cost?
API conversion costs $0.002 per request. The browser version can run locally for occasional manual formatting.
Does it change the wording of my lines?
No. It normalizes line endings and adds an incrementing number, a period, and a space before each original line.
Can the list begin with a number other than one?
Yes. Supply a positive integer in `start` to choose the first marker for a continued sequence.
What happens to blank lines?
Interior and trailing blank lines become empty numbered items. Remove them first if they should not appear in the result.
Will the result work in common Markdown renderers?
Yes. Each item uses the standard numeric marker format: an integer, a period, one space, and the line content.
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/str/markdown-numbered-list \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Install the dependencies\nConfigure the environment\nRun the test suite"}'const res = await fetch("https://api.kit.forhosting.com/str/markdown-numbered-list", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Install the dependencies\nConfigure the environment\nRun the test suite"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/markdown-numbered-list",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Install the dependencies\nConfigure the environment\nRun the test suite"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/markdown-numbered-list", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Install the dependencies\\nConfigure the environment\\nRun the test suite"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Install the dependencies\nConfigure the environment\nRun the test suite"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/markdown-numbered-list", 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": "Install the dependencies\nConfigure the environment\nRun the test suite"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.markdown_numbered_list",
"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_chars | 100000 |
max_lines | 10000 |
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. |