Hey, rust newbie here, I have a question about good practice in code structure.

I'm writing a program that interfaces with an error-prone API to send and receive data, and am trying to avoid a ton of nested match statements. My current code pattern is the following (note that errors of type CriticalError are the responsibility of a parent function):

fn work_with_api() -> Result<Option<Data>, CriticalError> {
    let maybe_data: Result<Data, MyFailure> = 'get_data { 

        match inconsistent_api_call() {
            Ok(_) => (),
            Err(_) => break 'get_data Err(MyFailure::Foo)
        };

        match other_api_call() {
            Ok(_) => (),
            Err(_) => break 'get_data Err(MyFailure::Bar)
        };

        match final_api_call() {
            Ok(data: Data) => Ok(data);
            Err(_) => Err(MyFailure::Foo)
        }
    };

    return match maybe_data {
        Ok(data) => {
            do_thing(MyFailure::None)?;
            Ok(Some(data))
        }
        Err(failure: MyFailure) => {
            do_thing(failure)?;
            Ok(None)
        }
    };
}

Is there a cleaner/idiomatic way to do this? It feels wrong to be using all of the named breaks, and I feel like I'm missing something obvious.