Interacting with APIs is a fundamental part of modern mobile app development. Whether you're fetching user data, displaying weather information, or handling login mechanisms, knowing how to effectively call APIs in iOS using Swift is crucial. This article will walk you through calling APIs in both UIKit and SwiftUI, explore different methods for API calls, and outline best practices to ensure your implementation is clean and efficient.

Methods to Call APIs in Swift

In iOS development, there are mainly three ways to make network calls:

1. URLSession (Native)
2. Third-party libraries like Alamofire
3. Combine (Reactive programming)

We'll focus on native and Combine approaches here for both UIKit and SwiftUI to keep things streamlined and Swifty.

Calling APIs in UIKit with URLSession

import UIKit
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        fetchData()
    }
    func fetchData() {
        guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts/1") else { return }
        URLSession.shared.dataTask(with: url) { data, response, error in
            if let error = error {
                print("Error: \(error)")
                return
            }
            guard let data = data else { return }
            do {
                let json = try JSONSerialization.jsonObject(with: data, options: [])
                print(json)
            } catch {
                print("Parsing error: \(error)")
            }
        }.resume()
    }
}

Calling APIs in SwiftUI with URLSession

import SwiftUI
struct ContentView: View {
    @State private var title: String = ""
    var body: some View {
        Text(title)
            .onAppear(perform: fetchData)
    }
    func fetchData() {
        guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts/1") else { return }
        URLSession.shared.dataTask(with: url) { data, response, error in
            if let data = data, let post = try? JSONDecoder().decode(Post.self, from: data) {
                DispatchQueue.main.async {
                    title = post.title
                }
            }
        }.resume()
    }
}
struct Post: Codable {
    let title: String
}

Using Combine for Reactive API Calls

Combine provides a more declarative and reactive way to handle data streams and network calls in SwiftUI:

import SwiftUI
import Combine
class PostViewModel: ObservableObject {
    @Published var title = ""
    var cancellables = Set<AnyCancellable>()
    func fetchPost() {
        guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts/1") else { return }
        URLSession.shared.dataTaskPublisher(for: url)
            .map { $0.data }
            .decode(type: Post.self, decoder: JSONDecoder())
            .replaceError(with: Post(title: "Error"))
            .receive(on: DispatchQueue.main)
            .sink { [weak self] post in
                self?.title = post.title
            }
            .store(in: &cancellables)
    }
}
struct ContentView: View {
    @StateObject var viewModel = PostViewModel()
    var body: some View {
        Text(viewModel.title)
            .onAppear {
                viewModel.fetchPost()
            }
    }
}

Best Practices

1. Use Codable Models: Parse JSON data using Codable instead of manual serialization.
2. Handle Errors Gracefully: Always check for error cases and provide user feedback.
3. Use Main Thread for UI Updates: Use DispatchQueue.main.async for UI changes.
4. Avoid Retain Cycles: Use [weak self] in closures.
5. Caching & Retry: Consider caching responses and retry mechanisms for improved UX.
6. Networking Layer: Abstract your network logic into a dedicated service layer.
7. Security: Never hardcode secrets in the code. Use HTTPS.

Conclusion

API integration is an essential skill in iOS development, and Swift provides powerful native tools like URLSession and Combine to make this process efficient. By following best practices, you can ensure your app performs well, is maintainable, and provides a smooth user experience.

About the Author

🚀 Mobile App Developer | iOS & Android | UI/UX Enthusiast I'm a passionate mobile app developer specializing in iOS and Android development, with a strong focus on SwiftUI, custom UI components, and cutting-edge UI design. From sleek user interfaces to powerful backend integrations, I love crafting apps that provide seamless user experiences.

I enjoy experimenting with different UI design styles, including Flat UI, Cyberpunk UI, and Neumorphism, to build modern and aesthetically pleasing applications. My journey also includes 3D game development and image processing techniques, pushing the limits of creativity in app design.

💡 Key Skills: SwiftUI, UIKit, Jetpack Compose, Cross-platform development, UI/UX design, Metal for graphics rendering.

📩 Contact me: 📧 garejakirit@gmail.com | 📍 Rajkot 🔗 LinkedIn: Kirit Gareja