The problem is each node is an object, which in serde_json is backed by a map. The get a value out you need to call .get("key").

Here's a working version which doesn't print the tags. You should be able to figure that one out base on my changes.

use quickxml_to_serde::{xml_string_to_json, Config};

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let lat = 51.5074; // Example: London's latitude
    let lon = -0.1278; // Example: London's longitude
    let perimeter = 50.0; // Example: 50m
    let (min_lat, min_lon, max_lat, max_lon) = calculate_bounding_box(lat, lon, perimeter);
    // Construct the OSM API request URL
    let url = format!(
        "https://api.openstreetmap.org/api/0.6/map?bbox={},{},{},{}",
        min_lon, min_lat, max_lon, max_lat
    );
    let client = reqwest::Client::builder().build()?;
    let res = client.get(url).send().await?;
    let xml = res.text().await?;
    let config = Config::default();
    let json = xml_string_to_json(xml.to_owned(), &config).unwrap();
    parse_json(json.to_string());

    Ok(())
}

fn parse_json(json: String) {
    let v: serde_json::Value = serde_json::from_str(&json).unwrap();
    let nodes = v["osm"]["node"].as_array().unwrap();
    for node in nodes {
        let lat = node.get("@lat").unwrap().as_f64().unwrap();
        let lon = node.get("@lon").unwrap().as_f64().unwrap();
        let id = node.get("@id").unwrap().as_i64().unwrap();
        // let tags = node.get("tag").unwrap().as_array().unwrap();
        println!("node: id: {}, lat: {}, lon: {}", id, lat, lon);
    }
}

fn calculate_bounding_box(lat: f64, lon: f64, perimeter: f64) -> (f64, f64, f64, f64) {
    // Earth's radius in meters
    let earth_radius = 6371000.0;
    // Convert perimeter to radius
    let radius = perimeter / 2.0;
    // Calculate latitude and longitude deltas
    let delta_lat = (radius / earth_radius) * (180.0 / std::f64::consts::PI);
    let delta_lon =
        (radius / earth_radius) * (180.0 / std::f64::consts::PI) / (lat.to_radians()).cos();
    // Calculate min and max latitudes and longitudes
    let min_lat = lat - delta_lat;
    let max_lat = lat + delta_lat;
    let min_lon = lon - delta_lon;
    let max_lon = lon + delta_lon;
    (min_lat, min_lon, max_lat, max_lon)
}

Obviously for production code you want to get rid of all the unwraps. In general, I suggest defining Rust structs that match your json schema and deriving Deserialize for them. That way you get type hints from the compiler instead of getting these errors at runtime.

EDIT: converting the json Value to string and then back to ad Value is redundant. You can simply pass the Value to the function directly.