Integrating REST APIs into Swift and SwiftUI Applications

Course: iOS App Development

Topic: Integrating REST APIs into Swift and SwiftUI Applications

Course Link: iOS App Development Training – JustAcademy

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction

REST API integration is an essential part of modern iOS application development. Many applications need to retrieve information from a server, submit user details, update records, authenticate users, and synchronize data across devices. REST APIs allow an iOS application to communicate with backend services over HTTP or HTTPS.

Swift provides language features for asynchronous programming, while Apple's URLSession framework handles network communication. SwiftUI provides declarative user interface components that can display API data and react to changes in application state.

When these technologies are combined, developers can build applications that load remote data, display loading indicators, handle errors, and update the interface without blocking the user.

Key technologies

• REST API: Provides endpoints for accessing server resources.
• Swift: Implements networking logic, models, and application behavior.
• URLSession: Sends HTTP and HTTPS requests and receives responses.
• Codable: Converts between JSON data and Swift model types.
• Swift concurrency: Uses async and await to manage asynchronous operations.
• SwiftUI: Builds interfaces that respond to changing application state.
• Observable state: Connects fetched data and request status to the user interface.

2. Learning Objectives

After completing this topic, learners should be able to:

• Understand how REST API integration works in an iOS application.
• Create API request URLs and configure HTTP methods and headers.
• Fetch remote data using URLSession.
• Decode JSON responses into Swift structures using Codable.
• Build a reusable API service layer.
• Display API data in SwiftUI lists and detail views.
• Manage loading, success, empty, and error states.
• Submit POST requests and understand update and delete operations.
• Apply basic networking security and performance practices.
• Test API integration and troubleshoot common errors.

3. Understanding REST API Integration

REST API integration connects the frontend of an application with backend services. The frontend presents information and collects user input, while the backend usually handles business logic, data storage, authentication, and authorization.

How an API request works

1. The user opens a screen or performs an action.
2. The application constructs a request for the appropriate API endpoint.
3. URLSession sends the request to the server.
4. The server validates the request and processes the operation.
5. The server returns an HTTP response containing a status code and, when applicable, a response body.
6. The application checks the response and decodes its JSON data.
7. The application updates its state with the returned data.
8. SwiftUI refreshes the relevant parts of the interface.

Example: In a shopping application, the product screen requests a list of products. The API returns JSON, Swift converts the response into product models, and SwiftUI displays the products in a list.

4. REST API Components

5. Common HTTP Methods Used in API Integration

Always follow the backend API documentation. The method, URL, request body, and authentication requirements depend on the specific service.

6. Preparing an iOS Project for API Integration

Before writing networking code, identify the API endpoint, expected response structure, supported methods, authentication requirements, and error format.

Preparation checklist

1. Open the iOS project in Xcode.
2. Choose an API endpoint that supports HTTPS.
3. Review the API documentation and sample JSON responses.
4. Identify the model types required by the application.
5. Decide where networking and data models will live in the project.
6. Plan loading, error, and empty states for the screen.
7. Confirm that the API can be accessed from the development environment.

For the examples below, https://api.example.com/products is a placeholder. Replace it with a real endpoint that returns the documented response structure.

7. Creating Swift Models with Codable

API responses commonly use JSON. Swift's Codable protocol makes it easier to convert between JSON data and strongly typed Swift models.

Example JSON response

[
  {
    "id": 101,
    "title": "Wireless Headphones",
    "price": 2499.0,
    "category": "Electronics"
  },
  {
    "id": 102,
    "title": "Travel Backpack",
    "price": 1599.0,
    "category": "Accessories"
  }
]

Corresponding Swift model

import Foundation

struct Product: Codable, Identifiable {
    let id: Int
    let title: String
    let price: Double
    let category: String
}

Explanation:

• Codable supports both encoding and decoding.
• Identifiable allows SwiftUI lists to identify each product using its id.
• Property names and data types must match the API response or be mapped appropriately.
• If the API uses different JSON keys, define a CodingKeys enum.

Mapping JSON keys

struct User: Codable, Identifiable {
    let id: Int
    let fullName: String

    enum CodingKeys: String, CodingKey {
        case id
        case fullName = "full_name"
    }
}

In this example, the API provides full_name, while the Swift property uses the more conventional camel-case name fullName.

8. Sending a GET Request Using URLSession

The URLSession API provides asynchronous methods for loading data from a URL. A GET request is commonly used to retrieve records from a server.

import Foundation

func fetchProducts() async throws -> [Product] {
    guard let url = URL(
        string: "https://api.example.com/products"
    ) else {
        throw URLError(.badURL)
    }

    let (data, response) = try await URLSession.shared.data(from: url)

    guard let httpResponse = response as? HTTPURLResponse else {
        throw URLError(.badServerResponse)
    }

    guard (200...299).contains(httpResponse.statusCode) else {
        throw URLError(.badServerResponse)
    }

    return try JSONDecoder().decode([Product].self, from: data)
}

How the code works

1. The URL is created from the API endpoint.
2. URLSession.shared.data(from:) sends the request asynchronously.
3. The returned response is checked to ensure it is an HTTP response.
4. The status code is checked before decoding.
5. JSONDecoder converts the JSON data into an array of Product models.
6. The function returns the decoded products or throws an error.

This example uses a generic error for a non-success status. Production applications should normally define API-specific errors and retain useful response details, such as the HTTP status code and a safe server-provided message.

9. Creating a Reusable API Service

A reusable service layer keeps network logic separate from SwiftUI views. This makes the application easier to test, maintain, and extend.

Example API service

import Foundation

enum APIError: Error {
    case invalidURL
    case invalidResponse
    case httpStatus(Int)
}

struct APIService {
    func fetchProducts() async throws -> [Product] {
        guard let url = URL(
            string: "https://api.example.com/products"
        ) else {
            throw APIError.invalidURL
        }

        let (data, response) = try await URLSession.shared.data(from: url)

        guard let httpResponse = response as? HTTPURLResponse else {
            throw APIError.invalidResponse
        }

        guard (200...299).contains(httpResponse.statusCode) else {
            throw APIError.httpStatus(httpResponse.statusCode)
        }

        return try JSONDecoder().decode([Product].self, from: data)
    }
}

Advantages of a service layer:

• Networking code is not duplicated across views.
• API endpoints and request logic are easier to maintain.
• Error handling can be standardized.
• Services can be replaced with mock implementations during testing.
• Views can focus on presentation rather than HTTP details.

10. Understanding Async and Await in Swift

Networking involves waiting for an external system. Swift's concurrency features allow asynchronous operations to be written in a readable way without blocking the main thread while the request is in progress.

func loadProducts() async {
    do {
        let products = try await APIService().fetchProducts()
        print("Loaded \(products.count) products")
    } catch {
        print("Unable to load products: \(error)")
    }
}

• async marks a function that can suspend while waiting for asynchronous work.
• await marks the point where the program waits for the asynchronous result.
• throws indicates that the function can report errors.
• do-catch handles errors thrown by the request or decoder.

Asynchronous networking helps keep the interface responsive. Avoid using blocking operations such as Thread.sleep or synchronous network calls on the main thread.

11. Building a SwiftUI ViewModel

A view model coordinates API requests and stores the state needed by a SwiftUI view. With modern SwiftUI, an @Observable model can expose changing values to the interface.

import Foundation
import Observation

@MainActor
@Observable
final class ProductViewModel {
    private let apiService = APIService()

    var products: [Product] = []
    var isLoading = false
    var errorMessage: String?

    func loadProducts() async {
        isLoading = true
        errorMessage = nil

        defer {
            isLoading = false
        }

        do {
            products = try await apiService.fetchProducts()
        } catch {
            errorMessage = "Unable to load products. Please try again."
        }
    }
}

Explanation

• @Observable makes relevant model changes observable by SwiftUI.
• @MainActor keeps UI-facing state updates on the main actor.
• products stores the fetched data.
• isLoading indicates whether a request is in progress.
• errorMessage holds a user-friendly error message.
• defer ensures that the loading state is reset when the function exits.

This example uses the Observation framework available in modern SwiftUI environments. For older deployment targets, a view model using ObservableObject and @Published may be more appropriate.

12. Displaying API Data in SwiftUI

SwiftUI provides views such as List, ForEach, Text, and ProgressView for displaying data and request states.

import SwiftUI

struct ProductListView: View {
    @State private var viewModel = ProductViewModel()

    var body: some View {
        NavigationStack {
            Group {
                if viewModel.isLoading && viewModel.products.isEmpty {
                    ProgressView("Loading products...")
                } else if let message = viewModel.errorMessage,
                          viewModel.products.isEmpty {
                    ContentUnavailableView(
                        "Unable to Load Products",
                        systemImage: "wifi.exclamationmark",
                        description: Text(message)
                    )
                } else if viewModel.products.isEmpty {
                    ContentUnavailableView(
                        "No Products",
                        systemImage: "shippingbox",
                        description: Text("No products are currently available.")
                    )
                } else {
                    List(viewModel.products) { product in
                        VStack(alignment: .leading, spacing: 6) {
                            Text(product.title)
                                .font(.headline)

                            Text(product.category)
                                .font(.subheadline)
                                .foregroundStyle(.secondary)

                            Text(
                                product.price,
                                format: .currency(code: "INR")
                            )
                        }
                    }
                }
            }
            .navigationTitle("Products")
            .task {
                if viewModel.products.isEmpty {
                    await viewModel.loadProducts()
                }
            }
            .refreshable {
                await viewModel.loadProducts()
            }
        }
    }
}

Important: The code assumes the Product, APIService, and ProductViewModel definitions from the preceding sections. ContentUnavailableView is available on newer Apple platform versions; use a custom view for older deployment targets if necessary.

13. Managing Loading, Success, Empty, and Error States

A robust API-driven interface should communicate what is happening. Users should not see an unexplained blank screen while a request is running or when the server returns no records.

For a better user experience, consider keeping previously loaded data visible when a refresh fails. This avoids unnecessarily replacing useful content with an error screen.

14. Sending POST Requests from Swift

POST requests commonly submit data to an API. For example, an application might create a new feedback record or submit a registration form.

import Foundation

struct FeedbackRequest: Codable {
    let name: String
    let message: String
}

func submitFeedback() async throws {
    guard let url = URL(
        string: "https://api.example.com/feedback"
    ) else {
        throw URLError(.badURL)
    }

    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue(
        "application/json",
        forHTTPHeaderField: "Content-Type"
    )
    request.setValue(
        "application/json",
        forHTTPHeaderField: "Accept"
    )

    let feedback = FeedbackRequest(
        name: "Aarav",
        message: "The application is easy to use."
    )

    request.httpBody = try JSONEncoder().encode(feedback)

    let (_, response) = try await URLSession.shared.data(for: request)

    guard let httpResponse = response as? HTTPURLResponse else {
        throw URLError(.badServerResponse)
    }

    guard (200...299).contains(httpResponse.statusCode) else {
        throw APIError.httpStatus(httpResponse.statusCode)
    }
}

The request body is encoded as JSON. The endpoint and payload must match the backend's contract. A successful POST may return 201 Created, 200 OK, 204 No Content, or another documented response.

15. Working with PUT, PATCH, and DELETE

Many applications need to modify or remove server resources. The request method, URL, and payload should match the endpoint's documented behavior.

These methods may require authentication and authorization. Do not assume that every API supports all three operations, or that every response contains JSON.

16. Handling HTTP Status Codes Correctly

A request can successfully reach the server but still return an unsuccessful HTTP status. Inspect HTTPURLResponse.statusCode to determine how the application should proceed.

17. Using Query Parameters and Search

Query parameters allow clients to filter, sort, search, or paginate results when the API supports those features. Build query strings with URLComponents to avoid manual URL-encoding mistakes.

import Foundation

func makeSearchURL(query: String) throws -> URL {
    guard var components = URLComponents(
        string: "https://api.example.com/products"
    ) else {
        throw URLError(.badURL)
    }

    components.queryItems = [
        URLQueryItem(name: "search", value: query),
        URLQueryItem(name: "page", value: "1"),
        URLQueryItem(name: "limit", value: "20")
    ]

    guard let url = components.url else {
        throw URLError(.badURL)
    }

    return url
}

For live search, consider debouncing input and cancelling obsolete requests. This can reduce unnecessary network traffic and prevent stale results from replacing newer search results.

18. Authentication and Secure Token Handling

Some APIs require a user to sign in before accessing protected resources. The application may need to attach an access token to the request.

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue(
    "Bearer \(accessToken)",
    forHTTPHeaderField: "Authorization"
)

This snippet illustrates the header format used by APIs that accept bearer tokens. It is not a complete authentication system.

• Use the authentication flow specified by the API provider.
• Store sensitive tokens securely, commonly using the iOS Keychain.
• Never hard-code production passwords or private API secrets in source code.
• Do not print access tokens or sensitive user information in logs.
• Handle expired tokens and sign-out behavior carefully.
• Enforce authorization on the server; hiding a button in the app is not a security control.

19. Networking Security Best Practices

• Use HTTPS in production.
• Keep TLS certificate validation enabled.
• Follow App Transport Security requirements.
• Validate server responses before displaying or processing them.
• Handle sensitive information in memory and logs carefully.
• Use the minimum permissions necessary.
• Validate user input on both the client and server.
• Follow rate limits and backend security recommendations.
• Use secure token storage and appropriate token expiration handling.
• Keep third-party libraries and SDKs updated.

20. Improving API Performance

API performance affects loading time, battery usage, data consumption, and the overall user experience.

• Pagination: Load large datasets in smaller pages when supported.
• Caching: Respect HTTP caching directives and validators.
• Request cancellation: Cancel requests that are no longer relevant.
• Efficient models: Decode only the structures needed by the application.
• Image loading: Load images asynchronously and use appropriate caching.
• Retry strategy: Retry transient failures cautiously and respect server instructions.
• Refresh behavior: Avoid duplicate requests caused by repeated view updates.
• Network monitoring: Measure request duration and diagnose recurring failures.

Do not blindly retry operations that may create duplicate records or trigger payments. Use API-supported idempotency keys or other safeguards when applicable.

21. Common API Integration Errors

22. Testing REST API Integration

Testing helps ensure that the networking layer behaves correctly when requests succeed, fail, or return unexpected data.

Recommended tests

• Test decoding with valid JSON.
• Test decoding with missing or incorrectly typed fields.
• Test HTTP success and failure status codes.
• Test offline conditions and timeouts.
• Test empty API responses.
• Test authentication failures.
• Verify that loading indicators stop after success or failure.
• Verify that SwiftUI updates correctly after data changes.
• Use mocked services or a custom URL protocol for deterministic networking tests.

Keep unit tests independent of a live production API whenever possible. Use a controlled test endpoint or mocked responses so that tests remain reliable.

23. Practical Project: Product Catalog App

Project goal: Create a SwiftUI application that fetches product information from a REST API and displays it in a responsive list.

Functional requirements

1. Create a Product model using Codable and Identifiable.
2. Build a reusable API service using URLSession.
3. Create a view model that manages products, loading state, and errors.
4. Display products in a SwiftUI List.
5. Show a progress indicator while loading.
6. Display a useful message when no products are available.
7. Provide a retry action after a failed request.
8. Support pull-to-refresh.
9. Add a product detail screen.
10. Test both successful and unsuccessful responses.

Suggested project structure

ProductCatalog/
├── Models/
│   └── Product.swift
├── Services/
│   └── APIService.swift
├── ViewModels/
│   └── ProductViewModel.swift
├── Views/
│   ├── ProductListView.swift
│   └── ProductDetailView.swift
└── ProductCatalogApp.swift

Possible extensions

• Add search, sorting, and category filters.
• Implement pagination.
• Add favorites and local persistence.
• Integrate login and protected endpoints.
• Display network errors with retry options.
• Write unit tests for the API service and view model.

24. Interview Questions and Answers

Q1. What is REST API integration in iOS?

It is the process of connecting an iOS application to backend services through HTTP requests and processing the returned responses.

Q2. What is URLSession?

URLSession is Apple's networking API for tasks such as fetching data, downloading files, and uploading content.

Q3. What is Codable?

Codable combines Swift's encoding and decoding capabilities, making it useful for converting JSON into Swift models and back.

Q4. Why use a service layer?

A service layer separates networking logic from views, reduces duplication, and makes testing and maintenance easier.

Q5. What is the purpose of a view model?

A view model coordinates application data and state for the interface, including loading status, results, and errors.

Q6. Why use async and await?

They make asynchronous operations easier to read and help the app wait for network results without blocking the user interface.

Q7. How does SwiftUI display API data?

SwiftUI observes relevant state and updates views when the model's data changes. Collections can be displayed using components such as List and ForEach.

Q8. Why should status codes be checked?

A network request can receive a valid HTTP response that represents a server-side failure. Checking the status prevents the app from treating all responses as successful.

Q9. How should API errors be handled?

Distinguish transport errors, HTTP errors, and decoding errors, then provide useful user-facing messages and safe diagnostic logging.

Q10. How can API integration be secured?

Use HTTPS, validate certificates, store tokens securely, avoid logging secrets, and enforce access permissions on the server.

Q11. What is the difference between a model and a view model?

A model represents application data, while a view model coordinates data and state used by a view.

Q12. How can duplicate network requests be avoided?

Control when requests start, track in-progress operations, cancel obsolete tasks, and avoid triggering requests unnecessarily during view updates.

25. Practice Exercises

1. Create a Swift model for a JSON response containing user IDs, names, and email addresses.
2. Write a GET request that fetches and decodes an array of users.
3. Create a SwiftUI list that displays the users.
4. Add loading, empty, and error states.
5. Write a POST request that submits a feedback form.
6. Display a retry button when a request fails.
7. Add query parameters for searching products.
8. Write tests for a successful response and an HTTP error.

26. Quick Revision Checklist

• REST APIs expose resources through documented endpoints.
• HTTP methods define the intended operation.
• URLSession handles network communication.
• URLRequest configures methods, headers, and request bodies.
• Codable supports JSON serialization and deserialization.
• async and await make asynchronous networking easier to manage.
• A service layer separates networking logic from the user interface.
• A view model manages data and UI-related state.
• SwiftUI updates views when observed state changes.
• Always check HTTP status codes and handle errors.
• Use HTTPS and secure authentication practices.
• Test empty responses, invalid data, and network failures.

27. Conclusion

Integrating REST APIs into Swift and SwiftUI applications allows developers to build connected, data-driven iOS experiences. By combining URLSession, Codable, Swift concurrency, a reusable networking service, and a state-driven SwiftUI interface, developers can retrieve remote data, submit information, and display useful results efficiently.

Good API integration requires more than sending a request. Applications should validate responses, handle errors gracefully, protect sensitive data, maintain responsive interfaces, and test different network conditions. Practicing these techniques through a product catalog or user directory project builds a strong foundation for professional iOS development.

Explore the iOS App Development Course: View iOS Training at JustAcademy

Register for a Demo: Book a Course Demo

Official Website: Visit JustAcademy