API Documentation

curl -X POST https://mdstill.com/api/convert \
  -H "Authorization: Bearer mdr_your_api_key" \
  -F "file=@document.pdf"

curl -X POST https://mdstill.com/api/convert \
  -H "Authorization: Bearer mdr_your_api_key" \
  -H "Accept: text/markdown" \
  -F "file=@report.pdf" \
  -o report.md

curl -s -X POST https://mdstill.com/api/convert \
  -H "Authorization: Bearer mdr_your_api_key" \
  -F "file=@report.pdf" \
  | jq -r '.markdown' > report.md

import requests

with open("document.pdf", "rb") as f:
    response = requests.post(
        "https://mdstill.com/api/convert",
        headers={"Authorization": "Bearer mdr_your_api_key"},
        files={"file": f},
        timeout=60,
    )

response.raise_for_status()
data = response.json()

markdown = data["markdown"]
meta = data["metadata"]
print(f"Converted in {meta['conversion_time_sec']}s, {meta['token_count']} tokens")

with open("document.md", "w") as f:
    f.write(markdown)

async function convertFile(file) {
  const form = new FormData();
  form.append("file", file);

  const response = await fetch("https://mdstill.com/api/convert", {
    method: "POST",
    headers: {
      Authorization: "Bearer mdr_your_api_key",
    },
    body: form,
  });

  if (!response.ok) {
    const err = await response.json().catch(() => ({}));
    throw new Error(err.detail || `HTTP ${response.status}`);
  }

  const { markdown, metadata } = await response.json();
  console.log(`Converted in ${metadata.conversion_time_sec}s`);
  return markdown;
}

import { readFile } from "node:fs/promises";

const buffer = await readFile("document.pdf");
const form = new FormData();
form.append("file", new Blob([buffer]), "document.pdf");

const response = await fetch("https://mdstill.com/api/convert", {
  method: "POST",
  headers: { Authorization: "Bearer mdr_your_api_key" },
  body: form,
});

if (!response.ok) {
  const err = await response.json().catch(() => ({}));
  throw new Error(err.detail || `HTTP ${response.status}`);
}

const { markdown, metadata } = await response.json();
console.log(`${metadata.markdown_length} chars, ~${metadata.token_count} tokens`);

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
)

type Response struct {
	Markdown string `json:"markdown"`
	Metadata struct {
		ConversionTimeSec float64 `json:"conversion_time_sec"`
		TokenCount        int     `json:"token_count"`
	} `json:"metadata"`
}

func main() {
	file, err := os.Open("document.pdf")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, _ := writer.CreateFormFile("file", "document.pdf")
	io.Copy(part, file)
	writer.Close()

	req, _ := http.NewRequest("POST", "https://mdstill.com/api/convert", body)
	req.Header.Set("Authorization", "Bearer mdr_your_api_key")
	req.Header.Set("Content-Type", writer.FormDataContentType())

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	var result Response
	json.NewDecoder(resp.Body).Decode(&result)
	fmt.Printf("Converted in %.2fs, ~%d tokens\n",
		result.Metadata.ConversionTimeSec, result.Metadata.TokenCount)
}

<?php
$ch = curl_init("https://mdstill.com/api/convert");

curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        "Authorization: Bearer mdr_your_api_key",
    ],
    CURLOPT_POSTFIELDS     => [
        "file" => new CURLFile("document.pdf"),
    ],
]);

$response = curl_exec($ch);
$status   = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($status !== 200) {
    throw new RuntimeException("API error: HTTP $status");
}

$data = json_decode($response, true);
echo "Converted in {$data['metadata']['conversion_time_sec']}s\n";
file_put_contents("document.md", $data["markdown"]);

mkdir -p output
for file in documents/*.pdf; do
  echo "Converting $file..."
  curl -s -X POST https://mdstill.com/api/convert \
    -H "Authorization: Bearer mdr_your_api_key" \
    -F "file=@$file" \
    | jq -r '.markdown' > "output/$(basename "$file" .pdf).md"
done

import requests

with open("report.pdf", "rb") as f:
    resp = requests.post(
        "https://mdstill.com/api/convert",
        headers={"Authorization": "Bearer mdr_your_api_key"},
        files={"file": f},
        data={"output": "structured", "chunk_tokens": "500"},
    )

data = resp.json()
chunks = data["structure"]["chunks"]

# Each chunk is ready for embedding
for chunk in chunks:
    print(f"Chunk {chunk['id']}: {chunk['tokens']} tokens")
    print(f"  Path: {' > '.join(chunk['heading_path']) or '(root)'}")
    print(f"  Types: {chunk['content_types']}")
    # embed(chunk["text"])  # your embedding call here

curl -s -X POST https://mdstill.com/api/convert \
  -H "Authorization: Bearer mdr_your_api_key" \
  -F "file=@report.pdf" \
  -F "output=structured" \
  -F "chunk_tokens=500" \
  | jq '.structure.chunks' > chunks.json

import { readFile } from "node:fs/promises";

const buffer = await readFile("report.pdf");
const form = new FormData();
form.append("file", new Blob([buffer]), "report.pdf");
form.append("output", "structured");
form.append("chunk_tokens", "500");

const resp = await fetch("https://mdstill.com/api/convert", {
  method: "POST",
  headers: { Authorization: "Bearer mdr_your_api_key" },
  body: form,
});

const { structure } = await resp.json();
console.log(`${structure.chunks.length} chunks, ${structure.total_tokens} tokens`);

// Feed chunks into your vector store
for (const chunk of structure.chunks) {
  await vectorStore.upsert({
    id: `report-${chunk.id}`,
    text: chunk.text,
    metadata: {
      heading_path: chunk.heading_path,
      content_types: chunk.content_types,
      tokens: chunk.tokens,
    },
  });
}