BlazeDocs API

curl -X POST https://blazedocs.io/api/v1/convert \
  -H "Authorization: Bearer bd_live_YOUR_KEY" \
  -F "file=@document.pdf"

# Response:
# {
#   "success": true,
#   "data": {
#     "markdown": "# Your Document\n\nConverted content...",
#     "page_count": 5,
#     "token_count": 4820,
#     "processing_time_ms": 3200
#   }
# }

import requests

resp = requests.post(
    "https://blazedocs.io/api/v1/convert",
    headers={"Authorization": "Bearer bd_live_YOUR_KEY"},
    files={"file": open("document.pdf", "rb")},
)
md = resp.json()["data"]["markdown"]
print(md)

const form = new FormData();
form.append("file", await fs.openAsBlob("document.pdf"));

const res = await fetch("https://blazedocs.io/api/v1/convert", {
  method: "POST",
  headers: { Authorization: "Bearer bd_live_YOUR_KEY" },
  body: form,
});
const { data } = await res.json();
console.log(data.markdown);

Authorization: Bearer bd_live_xxxxxxxxxx
# or
x-api-key: bd_live_xxxxxxxxxx

curl -X POST https://blazedocs.io/api/v1/convert \
  -H "Authorization: Bearer bd_live_YOUR_KEY" \
  -F "file=@document.pdf"

curl -X POST https://blazedocs.io/api/v1/convert \
  -H "Authorization: Bearer bd_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "file_base64": "<base64-encoded-pdf>",
    "file_name": "document.pdf"
  }'

{
  "success": true,
  "data": {
    "markdown": "# Document Title\n\nExtracted content with formatting...",
    "page_count": 5,
    "token_count": 4820,
    "processing_time_ms": 3200,
    "file_name": "document.pdf"
  },
  "usage": {
    "pages_used": 45,
    "pages_limit": 500,
    "pages_remaining": 455
  }
}

curl https://blazedocs.io/api/v1/convert \
  -H "Authorization: Bearer bd_live_YOUR_KEY"

{
  "tier": "starter",
  "usage": {
    "monthlyConversions": 12,
    "monthlyPages": 45,
    "monthlyTokens": 52000
  },
  "limits": {
    "conversions": 50,
    "pages": 500,
    "tokens": 500000,
    "fileSize": 20971520
  }
}

curl -X POST https://blazedocs.io/api/v1/keys \
  -H "Content-Type: application/json" \
  -H "Cookie: __session=YOUR_CLERK_SESSION" \
  -d '{"name": "production-key"}'

{
  "success": true,
  "key": {
    "id": "key_abc123",
    "name": "production-key",
    "key": "bd_live_xxxxxxxxxxxxxxxx",
    "created_at": "2025-01-15T10:30:00Z"
  }
}

const blazedocs = require("blazedocs");

// 1. Create session
const { sessionId, approvalUrl } = await blazedocs.connect.createSession({
  provider: "openclaw",
});
console.log("Open this link:", approvalUrl);

// 2. After user approves in browser...
const { apiKey } = await blazedocs.connect.exchange(sessionId);

// 3. Use the key
const client = new blazedocs.BlazeDocs({ apiKey });
const result = await client.convert({ file: "document.pdf" });
console.log(result.markdown);

from blazedocs import Client

client = Client()  # temporarily unauthenticated

# 1. Create session
session = client.create_connect_session(provider="openclaw")
print("Open this link:", session["approval_url"])

# 2. After user approves...
result = client.exchange_connect_session(session["session_id"])
api_key = result["api_key"]

# 3. Create a new authenticated client
client = Client(api_key=api_key)
conversion = client.convert("document.pdf")
print(conversion.markdown)

# One command: creates session, opens browser, stores key
npx blazedocs login --connect --provider openclaw

npm install -g @blazedocs/mcp-server

{
  "mcpServers": {
    "blazedocs": {
      "command": "npx",
      "args": ["-y", "@blazedocs/mcp-server"],
      "env": {
        "BLAZEDOCS_API_KEY": "bd_live_YOUR_KEY"
      }
    }
  }
}

from langchain.schema import Document
import requests

class BlazeDocsLoader:
    """LangChain document loader for BlazeDocs PDF conversion."""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.url = "https://blazedocs.io/api/v1/convert"

    def load(self, file_path: str) -> list[Document]:
        with open(file_path, "rb") as f:
            resp = requests.post(
                self.url,
                headers={"Authorization": f"Bearer {self.api_key}"},
                files={"file": (file_path, f, "application/pdf")},
            )
        data = resp.json()["data"]
        return [Document(
            page_content=data["markdown"],
            metadata={
                "source": file_path,
                "page_count": data["page_count"],
                "token_count": data["token_count"],
            },
        )]

# Usage with RAG pipeline
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = BlazeDocsLoader(api_key="bd_live_YOUR_KEY")
docs = loader.load("research_paper.pdf")

splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(docs)

vectorstore = FAISS.from_documents(chunks, OpenAIEmbeddings())
retriever = vectorstore.as_retriever()

import { openai } from "@ai-sdk/openai";
import { generateText, tool } from "ai";
import { z } from "zod";

const result = await generateText({
  model: openai("gpt-4o"),
  tools: {
    convertPdf: tool({
      description: "Convert a PDF file to Markdown using BlazeDocs",
      parameters: z.object({
        fileBase64: z.string().describe("Base64-encoded PDF"),
        fileName: z.string().describe("Original filename"),
      }),
      execute: async ({ fileBase64, fileName }) => {
        const res = await fetch("https://blazedocs.io/api/v1/convert", {
          method: "POST",
          headers: {
            Authorization: `Bearer ${process.env.BLAZEDOCS_API_KEY}`,
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            file_base64: fileBase64,
            file_name: fileName,
          }),
        });
        return res.json();
      },
    }),
  },
  prompt: "Convert the uploaded PDF and summarize its key findings.",
});

import openai, requests, json, base64

tools = [{
    "type": "function",
    "function": {
        "name": "convert_pdf_to_markdown",
        "description": "Convert a PDF document to Markdown text using BlazeDocs OCR",
        "parameters": {
            "type": "object",
            "properties": {
                "file_base64": {
                    "type": "string",
                    "description": "Base64-encoded PDF file content"
                },
                "file_name": {
                    "type": "string",
                    "description": "Name of the PDF file"
                }
            },
            "required": ["file_base64", "file_name"]
        }
    }
}]

def handle_tool_call(call):
    if call.function.name == "convert_pdf_to_markdown":
        args = json.loads(call.function.arguments)
        resp = requests.post(
            "https://blazedocs.io/api/v1/convert",
            headers={
                "Authorization": f"Bearer {BLAZEDOCS_KEY}",
                "Content-Type": "application/json",
            },
            json=args,
        )
        return resp.json()["data"]["markdown"]

# GPT will call convert_pdf_to_markdown when it needs to read a PDF
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Analyze this PDF..."}],
    tools=tools,
)

from crewai import Agent, Task, Crew
from crewai.tools import BaseTool
import requests

class BlazeDocsTool(BaseTool):
    name: str = "blazedocs_convert"
    description: str = "Convert a PDF file to Markdown text for analysis"

    def _run(self, file_path: str) -> str:
        with open(file_path, "rb") as f:
            resp = requests.post(
                "https://blazedocs.io/api/v1/convert",
                headers={"Authorization": f"Bearer {BLAZEDOCS_KEY}"},
                files={"file": (file_path, f, "application/pdf")},
            )
        return resp.json()["data"]["markdown"]

researcher = Agent(
    role="Research Analyst",
    goal="Extract insights from PDF documents",
    tools=[BlazeDocsTool()],
    llm="gpt-4o",
)

task = Task(
    description="Convert and analyze the research paper at paper.pdf",
    agent=researcher,
)

crew = Crew(agents=[researcher], tasks=[task])
result = crew.kickoff()

{
  "success": false,
  "error": "Human-readable error message",
  "code": "ERROR_CODE"
}