peasy-document

Async Rust client for the PeasyFormats API -- convert between Markdown, JSON, YAML, CSV, and other document formats with tools for format identification, MIME type lookup, and structured data transformation. Built with reqwest, serde, and tokio.

Built from PeasyFormats, a comprehensive document conversion toolkit offering free online tools for transforming between structured data formats. The glossary covers document formats from lightweight Markdown to structured JSON and YAML, while guides explain format conversion strategies and encoding best practices.

Try the interactive tools at peasyformats.com -- Markdown to HTML, YAML/JSON Converter, Format Identifier, and more.

Table of Contents

• Install
• Quick Start
• What You Can Do
  • Document Conversion Tools
  • Browse Document Format Reference
  • Search and Discovery
• API Client
  • Available Methods
• Learn More About Document Formats
• Also Available
• Peasy Developer Tools
• License

Install

[dependencies]
peasy-document = "0.2.0"
tokio = { version = "1", features = ["full"] }

Or via cargo:

cargo add peasy-document

Quick Start

use peasy_document::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // List available document tools
    let tools = client.list_tools(&Default::default()).await?;
    for tool in &tools.results {
        println!("{}: {}", tool.name, tool.description);
    }

    Ok(())
}

What You Can Do

Document Conversion Tools

Document format conversion is a core workflow for developers, data engineers, and content authors. Converting Markdown to HTML powers static site generators and documentation systems. Transforming JSON to YAML (and vice versa) is essential for configuration management across Kubernetes, Docker Compose, and CI/CD pipelines. CSV-to-JSON conversion bridges the gap between spreadsheet data and web APIs.

use peasy_document::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // Fetch the Markdown to HTML conversion tool
    let tool = client.get_tool("markdown-to-html").await?;
    println!("Tool: {}", tool.name);           // Markdown to HTML converter
    println!("Category: {}", tool.category);   // Document conversion category

    // List supported document formats and their MIME types
    let formats = client.list_formats(&Default::default()).await?;
    for fmt in &formats.results {
        println!(".{} -- {} ({})", fmt.extension, fmt.name, fmt.mime_type);
    }

    // List available format conversions from JSON
    let conversions = client.list_conversions(&peasy_document::ListConversionsOptions {
        source: Some("json".into()),
        ..Default::default()
    }).await?;
    println!("Found {} conversion paths from JSON", conversions.results.len());

    Ok(())
}

Learn more: Markdown to HTML Tool · YAML/JSON Converter · File Format Conversion Guide

Browse Document Format Reference

The document format glossary provides clear definitions for structured data formats, markup languages, and serialization standards. Understanding the differences between JSON and YAML syntax, when CSV is preferable to JSON for tabular data, and how Markdown flavors (CommonMark, GFM) differ helps developers choose the right format for each use case.

// Browse document format glossary terms
let glossary = client.list_glossary(&peasy_document::ListOptions {
    search: Some("csv".into()),
    ..Default::default()
}).await?;
for term in &glossary.results {
    println!("{}: {}", term.term, term.definition); // Document format definition
}

// Read in-depth guides on format conversion strategies
let guides = client.list_guides(&peasy_document::ListGuidesOptions {
    category: Some("document".into()),
    ..Default::default()
}).await?;
for guide in &guides.results {
    println!("{} ({})", guide.title, guide.audience_level); // Guide title and difficulty
}

Learn more: Markdown Glossary · JSON Glossary · How to Convert Markdown to Other Formats

Search and Discovery

The unified search endpoint queries across all document tools, glossary terms, guides, and supported file formats simultaneously. This is useful for building editor plugins, documentation search, or data pipeline tools that need to discover conversion capabilities.

// Search across all document tools, glossary, and guides
let results = client.search("markdown", Some(20)).await?;
println!("Found {} tools, {} glossary terms",
    results.results.tools.len(),
    results.results.glossary.len()); // Cross-content document format search results

Learn more: CSV Glossary · YAML Glossary · All Document Guides

API Client

The client wraps the PeasyFormats REST API with strongly-typed Rust structs using serde deserialization.

use peasy_document::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    // Or with a custom base URL:
    // let client = Client::with_base_url("https://custom.example.com");

    // List tools with filters
    let opts = peasy_document::ListOptions {
        page: Some(1),
        limit: Some(10),
        search: Some("markdown".into()),
        ..Default::default()
    };
    let tools = client.list_tools(&opts).await?;

    // Get a specific tool
    let tool = client.get_tool("markdown-to-html").await?;
    println!("{}: {}", tool.name, tool.description);

    // Search across all content
    let results = client.search("markdown", Some(20)).await?;
    println!("Found {} tools", results.results.tools.len());

    // Browse the glossary
    let glossary = client.list_glossary(&peasy_document::ListOptions {
        search: Some("csv".into()),
        ..Default::default()
    }).await?;
    for term in &glossary.results {
        println!("{}: {}", term.term, term.definition);
    }

    // Discover guides
    let guides = client.list_guides(&peasy_document::ListGuidesOptions {
        category: Some("document".into()),
        ..Default::default()
    }).await?;
    for guide in &guides.results {
        println!("{} ({})", guide.title, guide.audience_level);
    }

    // List format conversions
    let conversions = client.list_conversions(&peasy_document::ListConversionsOptions {
        source: Some("json".into()),
        ..Default::default()
    }).await?;

    Ok(())
}

Available Methods

Full API documentation at peasyformats.com/developers/. OpenAPI 3.1.0 spec: peasyformats.com/api/openapi.json.

Learn More About Document Formats

• Tools: Markdown to HTML · YAML/JSON Converter · Format Identifier · All Tools
• Guides: File Format Conversion Guide · How to Convert Markdown to Other Formats · All Guides
• Glossary: Markdown · CSV · JSON · YAML · All Terms
• Formats: All Formats
• API: REST API Docs · OpenAPI Spec

Also Available

Peasy Developer Tools

Part of the Peasy Tools open-source developer ecosystem.

Embed Widget

Embed PeasyDocument widgets on any website with peasy-document-embed:

<script src="https://cdn.jsdelivr.net/npm/peasy-document-embed@1/dist/embed.min.js"></script>
<div data-peasydocument="entity" data-slug="example"></div>

Zero dependencies · Shadow DOM · 4 themes (light/dark/sepia/auto) · Widget docs

License

MIT