ForHosting KIT · Data & Files

Markdown to HTML

Turn Markdown — from a CMS editor, a README, a support ticket, an AI-generated draft — into clean, sanitised HTML ready to render, without hosting a parser or worrying about a stray script tag sneaking through. It handles both plain CommonMark and the GitHub-flavoured extensions people actually write in practice: tables, task lists, strikethrough and fenced code blocks.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Markdown is a writing format, HTML is a rendering format

Content authors write in Markdown because it's fast and distraction-free, but browsers don't render Markdown — they render HTML, so somewhere between the editor and the page, a conversion has to happen. Doing that conversion correctly means more than swapping asterisks for bold tags: it means handling nested lists, nested blockquotes, nested code fences, nested links inside emphasis, and doing it consistently every time, which is precisely where hand-rolled regex-based converters fall apart.

CommonMark, GFM, and why the difference matters

CommonMark is the community-driven specification that formalized Markdown's originally ambiguous rules after years of every implementation behaving slightly differently; GitHub-flavoured Markdown (GFM) builds on it with tables, task list checkboxes, strikethrough and automatic URL linking, extensions that became so common in READMEs and documentation that most tools now support them by default. Our endpoint parses both, so a table copied from a GitHub README renders exactly as expected rather than as a wall of pipe characters.

How the conversion works

POST /data/markdown-to-html accepts raw Markdown text and returns HTML via task_id, with the output run through a sanitisation pass that strips or neutralises anything that could execute in a browser — inline event handlers, script tags, dangerous protocol links — so the result is safe to insert directly into a page even when the original Markdown came from an untrusted source, like a user comment or a public submission form.

What you get back and how fast

The response is standard HTML with semantic tags — proper heading levels, list nesting, table markup, code blocks wrapped for syntax highlighting — not a soup of inline styles, so it drops cleanly into any existing page template or CSS system. A typical document converts well within the response window, and for batch jobs like converting an entire documentation folder, you fire off each file as its own task and collect results via webhook as they complete.

Fitting into a content pipeline

This step sits naturally between an authoring tool and a publishing target: pair it with our HTML-to-Markdown converter to round-trip content between systems, or chain it after a text-generation step so AI-drafted Markdown lands as render-ready HTML in your CMS without a manual copy-paste step in between.

What you can do with it

Headless CMS rendering

Store content as Markdown for portability and convert it to HTML on demand at render time, keeping the source format editor-friendly and version-control-friendly.

Support ticket and comment systems

Sanitise and render Markdown submitted by end users so formatting works without opening the door to injected scripts.

Documentation pipelines

Batch-convert an entire repository of Markdown docs into HTML pages as part of a static site build triggered by a webhook.

AI-generated content workflows

Convert Markdown produced by a language model into publish-ready HTML before it reaches a CMS draft queue.

FAQ

How do I convert Markdown to HTML with the API?

POST your Markdown text to /data/markdown-to-html; you get a task_id and the resulting sanitised HTML arrives via webhook or a signed link.

Does it support GitHub-flavoured Markdown, like tables and task lists?

Yes, both plain CommonMark and GFM extensions — tables, task list checkboxes, strikethrough and autolinks — are supported.

Is the output safe to insert directly into a webpage?

Yes, the HTML is sanitised to strip scripts, inline event handlers and dangerous links, so it's safe even when the source Markdown came from an untrusted user.

Is there a free tier for the Markdown converter?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

What does the conversion cost?

$0.002 per request, regardless of document length, and a failed conversion after retries is never billed.

Can I convert a large batch of Markdown files at once?

Send each file as its own request; because every call is async, you can fire many in parallel and collect results as each webhook fires.

Does it preserve code block syntax highlighting hints?

Yes, fenced code blocks keep their language annotation in the output markup so a client-side highlighter can pick it up.

How is this different from a client-side JavaScript Markdown library?

It runs server-side, so there's no bundle size cost in the browser, and the sanitisation happens before the HTML ever reaches the client, which is safer for untrusted 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

POSThttps://api.kit.forhosting.com/data/markdown-to-html

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

const res = await fetch("https://api.kit.forhosting.com/data/markdown-to-html", {
  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/data/markdown-to-html",
    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/data/markdown-to-html", 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/data/markdown-to-html", 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": "data.markdown_to_html",
  "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

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

Limits

max_mb 25

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 →

Run — free