The Best SwiftUI Networking Libraries for 2026

struct APIClient {
    var baseURL: URL
    var session: URLSession = .shared

    func get<T: Decodable>(_ path: String, as type: T.Type = T.self) async throws -> T {
        let (data, response) = try await session.data(from: baseURL.appending(path: path))

        guard let http = response as? HTTPURLResponse else { throw APIError.badResponse }
        guard (200..<300).contains(http.statusCode) else {
            throw APIError.status(http.statusCode)
        }

        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        return try decoder.decode(T.self, from: data)
    }
}

enum APIError: Error {
    case badResponse
    case status(Int)
}

extension APIClient {
    func post<Body: Encodable, T: Decodable>(
        _ path: String,
        body: Body,
        as type: T.Type = T.self
    ) async throws -> T {
        var request = URLRequest(url: baseURL.appending(path: path))
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        let encoder = JSONEncoder()
        encoder.keyEncodingStrategy = .convertToSnakeCase
        request.httpBody = try encoder.encode(body)

        let (data, response) = try await session.data(for: request)
        guard let http = response as? HTTPURLResponse,
              (200..<300).contains(http.statusCode) else {
            throw APIError.badResponse
        }
        return try JSONDecoder().decode(T.self, from: data)
    }
}

func withRetry<T>(
    attempts: Int = 3,
    initialDelay: Duration = .milliseconds(300),
    operation: () async throws -> T
) async throws -> T {
    var delay = initialDelay

    for attempt in 1...attempts {
        do {
            return try await operation()
        } catch let error as APIError {
            // A 4xx will fail identically next time — do not burn retries on it.
            if case .status(let code) = error, (400..<500).contains(code) { throw error }
            if attempt == attempts { throw error }
        } catch {
            if attempt == attempts { throw error }
        }
        try await Task.sleep(for: delay)
        delay *= 2
    }

    throw APIError.badResponse
}

enum Loadable<Value> {
    case idle
    case loading
    case loaded(Value)
    case failed(Error)
}

@MainActor
final class FeedViewModel: ObservableObject {
    @Published private(set) var state: Loadable<[Post]> = .idle
    private let api: APIClient

    init(api: APIClient) { self.api = api }

    func load() async {
        state = .loading
        do {
            state = .loaded(try await api.get("/posts", as: [Post].self))
        } catch {
            state = .failed(error)
        }
    }
}

struct FeedView: View {
    @StateObject var vm: FeedViewModel

    var body: some View {
        Group {
            switch vm.state {
            case .idle, .loading:
                ProgressView()
            case .loaded(let posts) where posts.isEmpty:
                EmptyStateView(icon: "tray", title: "Nothing yet", message: "New posts appear here.")
            case .loaded(let posts):
                List(posts) { Text($0.title) }
            case .failed(let error):
                ErrorStateView(message: error.localizedDescription) { Task { await vm.load() } }
            }
        }
        .task { await vm.load() }
    }
}

struct SearchScreen: View {
    @State private var query = ""
    @State private var results: [Post] = []

    var body: some View {
        List(results) { Text($0.title) }
            .searchable(text: $query)
            // Re-runs on every query change AND cancels the previous request,
            // which is what stops results arriving out of order.
            .task(id: query) {
                guard query.count >= 2 else { results = []; return }
                do {
                    try await Task.sleep(for: .milliseconds(250))   // debounce
                    results = try await api.get("/search?q=(query)", as: [Post].self)
                } catch {
                    // CancellationError is expected here — ignore it.
                }
            }
    }
}

func upload(image: Data, to url: URL, fileName: String = "photo.jpg") async throws {
    let boundary = "Boundary-(UUID().uuidString)"
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("multipart/form-data; boundary=(boundary)",
                     forHTTPHeaderField: "Content-Type")

    var body = Data()
    body.append("--(boundary)
".data(using: .utf8)!)
    body.append("Content-Disposition: form-data; name="file"; filename="(fileName)"
"
        .data(using: .utf8)!)
    body.append("Content-Type: image/jpeg

".data(using: .utf8)!)
    body.append(image)
    body.append("
--(boundary)--
".data(using: .utf8)!)   // trailing -- is required

    let (_, response) = try await URLSession.shared.upload(for: request, from: body)
    guard let http = response as? HTTPURLResponse,
          (200..<300).contains(http.statusCode) else { throw APIError.badResponse }
}