Struct BrawlClient 

pub struct BrawlClient { /* private fields */ }

Main client for interacting with the Brawl Stars API.

The BrawlClient handles all HTTP communication with the Brawl Stars API, including authentication, error handling, and JSON deserialization.

Examples

use brawl_rs::prelude::*;

let client = BrawlClient::new("your_api_token_here");

Implementations

impl BrawlClient

pub fn new(api_key: impl Into<String>) -> Self

Creates a new BrawlClient with the provided API key.

The API key can be obtained from the Brawl Stars Developer Portal.

Arguments

• api_key - Your Brawl Stars API token for authentication

Examples

use brawl_rs::prelude::*;

let client = BrawlClient::new("eyJ0eXAiOiJKV1QiLCJhbGci...");

Examples found in repository

examples/player.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = BrawlClient::new(var("BRAWL_TOKEN")?);

    // Fetch player information
    // Note: Replace with a valid player tag
    match Player::get(&client, "20YY0G9L0").await {
        Ok(mut player) => {
            println!("=== Player Information ===");
            println!("Name: {}", player.name);
            println!("Trophies: {}", player.trophies);
            println!("Highest Trophies: {}", player.highest_trophies);
            println!("Level: {}", player.exp_level);
            println!("Prestige: {}", player.total_prestige_level);
            println!("Experience Points: {}", player.exp_points);
            println!("\n=== Victories ===");
            println!("3v3: {}", player.victories_3v3);
            println!("Solo: {}", player.solo_victories);
            println!("Duo: {}", player.duo_victories);

            if let Some(club_name) = &player.club.name {
                println!("\n=== Club ===");
                println!("Name: {}", club_name);
                println!("Tag: {}", player.club.tag.as_deref().unwrap_or("N/A"));
            }

            println!("\n=== Brawlers ({} total) ===", player.brawlers.len());
            player
                .brawlers
                .sort_by(|x, x1| x1.trophies.cmp(&x.trophies));

            for brawler in player.brawlers.iter().take(10) {
                println!(
                    "{}: Power {}, Trophies {}, Rank {}",
                    brawler.name, brawler.power, brawler.trophies, brawler.rank
                );
            }
        }
        Err(e) => eprintln!("Error fetching player: {:?}", e),
    }

    Ok(())
}

examples/battle_log.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = BrawlClient::new(var("BRAWL_TOKEN")?);

    // ==========================================
    // FETCH BATTLE LOG
    // ==========================================

    println!("=== Battle Log ===\n");
    match BattleLog::get(&client, "20YY0G9L0").await {
        Ok(battle_log) => {
            println!("Found {} battles:\n", battle_log.items.len());

            for (i, battle) in battle_log.items.iter().enumerate().take(3) {
                println!("=== Battle #{} ===", i + 1);

                // Battle time
                println!("Battle Time: {}", battle.battle_time);

                // Event information
                println!("Event ID: {}", battle.event.id);
                println!("Event Mode ID: {}", battle.event.mode_id);
                if let Some(map) = &battle.event.map {
                    println!("Event Map: {}", map);
                }

                // Battle information
                println!("Battle Mode: {}", battle.battle.mode);
                println!("Battle Type: {}", battle.battle.kind);

                if let Some(result) = &battle.battle.result {
                    println!("Result: {}", result);
                }

                if let Some(rank) = battle.battle.rank {
                    println!("Rank: {}", rank);
                }

                if let Some(trophy_change) = battle.battle.trophy_change {
                    println!("Trophy Change: {}", trophy_change);
                }

                // Star player
                if let Some(star_player) = &battle.battle.star_player {
                    println!("Star Player:");
                    println!("  Tag: {}", star_player.tag);
                    println!("  Name: {}", star_player.name);
                    println!("  Brawler ID: {}", star_player.brawler.id);
                    println!("  Brawler Name: {}", star_player.brawler.name);
                    println!("  Brawler Power: {}", star_player.brawler.power);
                    println!("  Brawler Trophies: {}", star_player.brawler.trophies);
                }

                // Players
                println!("Players ({}):", battle.battle.players.len());
                for (j, player) in battle.battle.players.iter().enumerate() {
                    println!("  Player {}:", j + 1);
                    println!("    Tag: {}", player.tag);
                    println!("    Name: {}", player.name);
                    println!("    Brawler ID: {}", player.brawler.id);
                    println!("    Brawler Name: {}", player.brawler.name);
                    println!("    Brawler Power: {}", player.brawler.power);
                    println!("    Brawler Trophies: {}", player.brawler.trophies);
                }

                // Teams (if available)
                if let Some(teams) = &battle.battle.teams {
                    println!("Teams ({} teams):", teams.len());
                    for (team_idx, team) in teams.iter().enumerate() {
                        println!("  Team {} ({} players):", team_idx + 1, team.len());
                        for (player_idx, player) in team.iter().enumerate() {
                            println!(
                                "    Player {}: {} ({})",
                                player_idx + 1,
                                player.name,
                                player.brawler.name
                            );
                        }
                    }
                }

                println!("\n");
            }
        }
        Err(e) => eprintln!("Error fetching battle log: {}", e),
    }

    Ok(())
}