peasy-audio

Async Rust client for the PeasyAudio API — analyze BPM, calculate bitrate, and convert audio formats. Built with reqwest, serde, and tokio.

Built from PeasyAudio, a comprehensive audio toolkit offering free online tools for analyzing tempo, calculating file sizes, comparing audio formats, and converting between MP3, WAV, FLAC, OGG, and AAC. The site includes in-depth guides on lossless vs. lossy audio encoding, format comparison charts, and a glossary covering concepts from bitrate and sample rate to audio codecs and clipping.

Try the interactive tools at peasyaudio.com — Audio BPM Analyzer, Audio Frequency Calculator, Audio File Size Calculator, and more.

Table of Contents

• Install
• Quick Start
• What You Can Do
  • Audio Analysis Tools
  • Browse Reference Content
  • Search and Discovery
• API Client
  • Available Methods
• Learn More About Audio Tools
• Also Available
• Peasy Developer Tools
• License

Install

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

Or via cargo:

cargo add peasy-audio

Quick Start

use peasy_audio::Client;

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

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

    Ok(())
}

What You Can Do

Audio Analysis Tools

Digital audio is represented as a series of samples captured at a fixed rate — CD-quality audio uses 44,100 samples per second (44.1 kHz) with 16-bit depth, producing 1,411 kbps of uncompressed data. Lossy codecs like MP3 and AAC reduce this dramatically (128-320 kbps) by discarding inaudible frequencies using psychoacoustic models, while lossless codecs like FLAC compress without any data loss. PeasyAudio provides calculators and analysis tools for understanding these encoding parameters.

use peasy_audio::Client;

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

    // Get the BPM analyzer tool for tempo detection
    let tool = client.get_tool("audio-bpm").await?;
    println!("Tool: {}", tool.name);              // Audio BPM analyzer name
    println!("Description: {}", tool.description); // How BPM detection works

    // List all available audio tools with pagination
    let opts = peasy_audio::ListOptions {
        page: Some(1),
        limit: Some(20),
        ..Default::default()
    };
    let tools = client.list_tools(&opts).await?;
    println!("Total audio tools available: {}", tools.count);

    Ok(())
}

Learn more: Audio BPM Analyzer · Audio Format Comparison · Convert Between Audio Formats

Browse Reference Content

PeasyAudio includes a comprehensive glossary of audio engineering terminology and practical guides for common workflows. The glossary covers foundational concepts like bitrate (the number of bits processed per second, determining audio quality and file size), sample rate (how many times per second the audio signal is measured), WAV (Microsoft's uncompressed audio container), and FLAC (Free Lossless Audio Codec, the open-source standard for archival-quality audio).

use peasy_audio::Client;

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

    // Browse the audio glossary for encoding and format terminology
    let glossary = client.list_glossary(&peasy_audio::ListOptions {
        search: Some("bitrate".into()), // Search for audio encoding concepts
        ..Default::default()
    }).await?;
    for term in &glossary.results {
        println!("{}: {}", term.term, term.definition);
    }

    // Read a guide comparing lossless vs lossy audio formats
    let guide = client.get_guide("audio-format-comparison").await?;
    println!("Guide: {} (Level: {})", guide.title, guide.audience_level);

    Ok(())
}

Learn more: Audio Glossary · Audio Format Comparison · Convert Between Audio Formats

Search and Discovery

The API supports full-text search across all content types — tools, glossary terms, guides, use cases, and format documentation. Search results are grouped by content type, making it easy to find the right tool or reference for any audio workflow.

use peasy_audio::Client;

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

    // Search across all audio content — tools, glossary, guides, and formats
    let results = client.search("convert flac", Some(20)).await?;
    println!("Found {} tools, {} glossary terms, {} guides",
        results.results.tools.len(),
        results.results.glossary.len(),
        results.results.guides.len(),
    );

    // Discover format conversion paths — what can WAV convert to?
    let conversions = client.list_conversions(&peasy_audio::ListConversionsOptions {
        source: Some("wav".into()), // Find all formats WAV can be converted to
        ..Default::default()
    }).await?;
    for c in &conversions.results {
        println!("{} -> {}", c.source_format, c.target_format);
    }

    Ok(())
}

Learn more: REST API Docs · All Audio Tools

API Client

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

use peasy_audio::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_audio::ListOptions {
        page: Some(1),
        limit: Some(10),
        search: Some("convert".into()),
        ..Default::default()
    };
    let tools = client.list_tools(&opts).await?;

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

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

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

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

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

    Ok(())
}

Available Methods

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

Learn More About Audio Tools

• Tools: Audio BPM Analyzer · Audio Frequency Calculator · Audio File Size Calculator · All Tools
• Guides: Audio Format Comparison · Convert Between Audio Formats · All Guides
• Glossary: Bitrate · Sample Rate · WAV · FLAC · 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.

License

MIT