Using async/await with RESTful APIs in Swift and SwiftUI 🚀

In modern app development, networking is a critical part of most applications. Whether you’re fetching data, sending updates, or communicating with a backend service, efficient and seamless network operations are essential. Swift’s async/await paradigm, introduced in Swift 5.5, simplifies asynchronous code, making it more readable and less prone to callback hell.

In this blog post, we’ll explore how you can leverage async/await to work with RESTful APIs in a SwiftUI project, focusing on cleaner and more concise code. Let's dive into how to fetch data, handle errors, and display that data using SwiftUI. ✔️

Why Use async/await? 🤔

Before Swift 5.5, asynchronous programming often involved using completion handlers or closures, which could quickly become hard to read, especially when chaining multiple network calls. The async/await feature simplifies this by allowing you to write asynchronous code in a sequential manner while still avoiding blocking the main thread. This improves readability and maintainability.

Here's why async/await is awesome:

• Simplified code: Write asynchronous tasks sequentially.

• Error handling: Use the powerful do-catch structure for errors.

• No callback hell: Avoid deeply nested closures.

• Better flow: The logic becomes easier to follow.

---

Step-by-Step Guide: Using async/await with RESTful APIs in SwiftUI 🔧

Let's walk through building a simple app that fetches data from a RESTful API and displays it using SwiftUI.

1. Setting Up the Model 💡

We’ll first create a simple model that represents the data we want to fetch from an API. Let’s assume we’re fetching a list of posts from a typical REST API.

struct Post: Codable, Identifiable {
let id: Int
let title: String
let body: String
}
Here, the Post struct conforms to Codable for easy decoding of JSON data, and Identifiable so that SwiftUI can work with lists efficiently.

2. Networking Layer: Using async/await 🕸️

Now, let’s write the networking code that fetches data from an API using async/await.

import Foundation

    class APIService {
static let shared = APIService()

func fetchPosts() async throws -> [Post] {
    let urlString = "https://jsonplaceholder.typicode.com/posts"
    guard let url = URL(string: urlString) else {
        throw URLError(.badURL)
    }
    // Make the network call using async/await
    let (data, response) = try await URLSession.shared.data(from: url)

    // Validate the response
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }

    // Decode the data
    let posts = try JSONDecoder().decode([Post].self, from: data)
    return posts
    }
}

Explanation:

• The fetchPosts function uses the async keyword, making it asynchronous.

• The await keyword suspends execution until the network request completes, avoiding the need for a closure.

• We use URLSession.shared.data(from:) to fetch data from the API, and try await to handle errors.

• The result is decoded into an array of Post objects using JSONDecoder.

3. SwiftUI View: Displaying the Data 🖼️

Next, we’ll display the fetched data in a SwiftUI view. We’ll create a ViewModel that handles the data fetching using @MainActor to ensure UI updates happen on the main thread.

import SwiftUI

@MainActor
class PostViewModel: ObservableObject {
@Published var posts: [Post] = []
@Published var isLoading = false
@Published var errorMessage: String? = nil
func loadPosts() async {
isLoading = true
errorMessage = nil
do {
posts = try await APIService.shared.fetchPosts()
} catch {
errorMessage = "Failed to load posts: (error.localizedDescription)"
}
isLoading = false
}
}

Explanation:

• PostViewModel conforms to ObservableObject, which allows the UI to react to changes in the posts array.

• The loadPosts function uses async and calls the network method using await, handling any errors in the catch block.

4. Connecting to the SwiftUI View 🌄

Now, let’s use this PostViewModel in a SwiftUI view to display the list of posts.

struct ContentView: View {
@StateObject private var viewModel = PostViewModel()
var body: some View {
    NavigationView {
        if viewModel.isLoading {
            ProgressView("Loading...")
        } else if let errorMessage = viewModel.errorMessage {
            Text(errorMessage)
        } else {
            List(viewModel.posts) { post in
                VStack(alignment: .leading) {
                    Text(post.title)
                        .font(.headline)
                    Text(post.body)
                        .font(.subheadline)
                        .foregroundColor(.secondary)
                }
            }
            .navigationTitle("Posts")
            .task {
                await viewModel.loadPosts()
            }
        }
    }
}
}

Explanation:

• We use @StateObject to manage the view model, ensuring it's retained across view updates.

• Depending on the state (isLoading, errorMessage), we show a loading spinner, error message, or the list of posts.

• The .task modifier triggers the loadPosts function as soon as the view appears.

---

Error Handling with async/await ❗

One of the strengths of async/await is its integration with Swift’s throw and do-catch for error handling. In our example, if the network request fails, the error is thrown and caught in the do-catch block, allowing us to handle failures cleanly.

For example:

do {
let posts = try await APIService.shared.fetchPosts()
} catch {
print("Error: (error.localizedDescription)")
}
This eliminates the need for complex error-handling mechanisms in completion handlers.

---

Conclusion 🎉

By using async/await in Swift and SwiftUI, we can write cleaner, more readable code that handles networking in a modern and efficient way. The flow of execution is sequential, easy to understand, and avoids the pyramid of doom that can occur with nested closures.

This makes it an ideal approach for interacting with RESTful APIs, especially when combined with SwiftUI’s declarative nature. You get both a powerful and simple way to manage asynchronous tasks while keeping your codebase elegant and maintainable.

Give it a try in your next SwiftUI project! Your network calls will be cleaner, faster, and more reliable than ever! 🔨🤖🔧

Happy coding!