Introduction

When you fire multiple Alamofire requests and need a single action after all responses arrive, you need coordination primitives, not ad hoc counters scattered across callbacks. Without structured coordination, race conditions and missed completion paths are common, especially when one request fails early. In modern Swift, you can solve this with DispatchGroup for callback-based code, or with async/await and task groups for cleaner flow control. The key design choice is whether partial failures are acceptable and how to aggregate results. This guide shows robust patterns for waiting on multiple asynchronous responses in Alamofire-backed code.

Core Sections

1. DispatchGroup for callback-style Alamofire

1import Alamofire
2
3let group = DispatchGroup()
4var profile: UserProfile?
5var orders: [Order] = []
6var errors: [Error] = []
7
8group.enter()
9AF.request("/api/profile").responseDecodable(of: UserProfile.self) { response in
10    defer { group.leave() }
11    switch response.result {
12    case .success(let value): profile = value
13    case .failure(let err): errors.append(err)
14    }
15}
16
17group.enter()
18AF.request("/api/orders").responseDecodable(of: [Order].self) { response in
19    defer { group.leave() }
20    switch response.result {
21    case .success(let value): orders = value
22    case .failure(let err): errors.append(err)
23    }
24}
25
26group.notify(queue: .main) {
27    if errors.isEmpty {
28        render(profile: profile, orders: orders)
29    } else {
30        showCombinedError(errors)
31    }
32}

Always pair enter() and leave() exactly once, including failure paths.

2. Async/await wrapper with Alamofire serialization

If your codebase supports Swift concurrency, wrap requests in async functions and use structured concurrency.

1func fetchProfile() async throws -> UserProfile {
2    try await AF.request("/api/profile")
3        .serializingDecodable(UserProfile.self)
4        .value
5}
6
7func fetchOrders() async throws -> [Order] {
8    try await AF.request("/api/orders")
9        .serializingDecodable([Order].self)
10        .value
11}
12
13func loadDashboard() async {
14    do {
15        async let p = fetchProfile()
16        async let o = fetchOrders()
17        let (profile, orders) = try await (p, o)
18        await MainActor.run { render(profile: profile, orders: orders) }
19    } catch {
20        await MainActor.run { showError(error) }
21    }
22}

This is easier to maintain than nested callbacks and manual synchronization.

3. Handling partial success requirements

Sometimes one response is optional while another is mandatory. Model this explicitly with a result aggregator:

1struct DashboardPayload {
2    let profile: UserProfile
3    let orders: [Order]?
4}

Treat optional endpoints as best-effort and keep critical dependencies strict. This avoids masking critical failures.

4. Timeouts and cancellation

Set request-level timeouts and propagate cancellation when the screen disappears. For task-based code, cancel the parent task and let child requests stop when possible.

5. Threading and state safety

Collecting results from multiple callbacks mutates shared state. Keep aggregation on one queue or use MainActor updates only after all results are ready.

Validation and production readiness

A reliable implementation should include more than a working snippet. Add a small reproducible dataset or input fixture that exercises expected behavior and edge cases, then codify it in automated tests. Include at least one “happy path,” one malformed input case, and one boundary condition so regressions are caught early. Instrument key steps with structured logs or metrics to make failures diagnosable in runtime environments, not just local development. If performance is relevant, keep a lightweight benchmark that can be rerun after refactors to ensure behavior stays within budget.

Operationally, document assumptions near the code: required library versions, environment variables, timezone/locale expectations, and failure handling strategy. For team workflows, add one integration test that mirrors real usage rather than only unit-level checks. This reduces drift between example code and production behavior. Treat these checks as part of feature completion, because most long-term issues are caused by unvalidated assumptions rather than syntax errors.

Common Pitfalls

• Forgetting group.leave() on error branches, causing notify never to run.
• Updating shared arrays from multiple callbacks without queue discipline.
• Treating all endpoint failures the same when business logic needs partial success.
• Nesting requests deeply instead of using concurrency primitives.
• Updating UI from background callbacks without dispatching to the main actor/queue.

Summary

To wait for multiple Alamofire responses, choose a structured coordination strategy and apply it consistently. DispatchGroup works well for callback code, while async/await offers cleaner composition and error handling. Define your failure policy up front, handle cancellation explicitly, and update UI only on the main thread. With these patterns, multi-request screens become predictable and maintainable.