Swift SDK

Use PowerSync in Swift apps.

Source Code

Refer to the powersync-swift repo on GitHub

API Reference

Full API reference for the SDK

Example Projects

Gallery of example projects/demo apps built with PowerSync and Swift

Changelog

Changelog for the SDK

Earlier versions of the Swift SDK (up to v1.13) shipped a PowerSync Kotlin XCFramework under the hood and abstracted it behind Swift protocols.

From v1.14 onward, the Kotlin dependency has been removed entirely. The SDK is now implemented natively in Swift, with the PowerSync sync protocol and SQLite extension handled by our Rust core.

SDK Features

• Real-time streaming of database changes: Changes made by one user are instantly streamed to all other users with access to that data. This keeps clients automatically in sync without manual polling or refresh logic.
• Direct access to a local SQLite database: Data is stored locally, so apps can read and write instantly without network calls. This enables offline support and faster user interactions.
• Asynchronous background execution: The SDK performs database operations in the background to avoid blocking the application’s main thread. This means that apps stay responsive, even during heavy data activity.
• Query subscriptions for live updates: The SDK supports query subscriptions that automatically push real-time updates to client applications as data changes, keeping your UI reactive and up to date.
• Automatic schema management: PowerSync syncs schemaless data and applies a client-defined schema using SQLite views. This architecture means that PowerSync SDKs can handle schema changes gracefully without requiring explicit migrations on the client-side.

Installation

You can add the PowerSync Swift package to your project using either Package.swift or Xcode:

Package.swift

let package = Package(
    //...
    dependencies: [
        //...
        .package(
            url: "https://github.com/powersync-ja/powersync-swift",
            exact: "<version>"
        ),
    ],
    targets: [
        .target(
            name: "YourTargetName",
            dependencies: [
                .product(
                    name: "PowerSync",
                    package: "powersync-swift"
                )
            ]
        )
    ]
)

Xcode

1. Follow this guide to add a package to your project.
2. Use https://github.com/powersync-ja/powersync-swift.git as the URL
3. Include the exact version (e.g., 1.0.x)

Getting Started

Prerequisites: To sync data between your client-side app and your backend source database, you must have completed the necessary setup for PowerSync, which includes connecting your source database to the PowerSync Service and deploying Sync Streams (or legacy Sync Rules) (steps 1-4 in the Setup Guide).

1. Define the Client-Side Schema

This refers to the schema for the managed SQLite database exposed by the PowerSync Client SDKs, that your app can read from and write to. The schema is applied when the database is instantiated (as we’ll show in the next step) — no migrations are required.

Generate schema automatically

In the PowerSync Dashboard, select your project and instance and click the Connect button in the top bar to generate the client-side schema in your preferred language. The schema will be generated based off your Sync Streams/Rules.

Similar functionality exists in the CLI.

Note: The generated schema will not include an id column, as the client SDK automatically creates an id column of type text. Consequently, it is not necessary to specify an id column in your schema. For additional information on IDs, refer to Client ID.

The types available are text, integer and real. These should map directly to the values produced by your Sync Streams (or legacy Sync Rules). If a value doesn’t match, it is cast automatically. For details on how backend source database types are mapped to the SQLite types, see Types.

Example:

import Foundation
import PowerSync

let LISTS_TABLE = "lists"
let TODOS_TABLE = "todos"

let lists = Table(
    name: LISTS_TABLE,
    columns: [
        // ID column is automatically included
        .text("name"),
        .text("created_at"),
        .text("owner_id")
    ]
)

let todos = Table(
    name: TODOS_TABLE,
    // ID column is automatically included
    columns: [
        .text("list_id"),
        .text("photo_id"),
        .text("description"),
        // 0 or 1 to represent false or true
        .integer("completed"),
        .text("created_at"),
        .text("completed_at"),
        .text("created_by"),
        .text("completed_by")
    ],
    indexes: [
        Index(
            name: "list_id",
            columns: [
                IndexedColumn.ascending("list_id")
            ]
        )
    ]
)

let AppSchema = Schema(lists, todos)

Note: No need to declare a primary key id column, as PowerSync will automatically create this.

2. Instantiate the PowerSync Database

Next, you need to instantiate the PowerSync database. PowerSync streams changes from your backend source database into the client-side SQLite database, based on your Sync Streams (or legacy Sync Rules). In your client-side app, you can read from and write to the local SQLite database, whether the user is online or offline.

Example:

let schema = AppSchema // Comes from the AppSchema defined above
let db = PowerSyncDatabase(
    schema: schema,
    dbFilename: "powersync-swift.sqlite"
)

3. Integrate with Your Backend

Create a connector to integrate with your backend. The PowerSync backend connector provides the connection between your application backend and the PowerSync managed database. It is used to:

1. Retrieve an auth token to connect to the PowerSync instance.

2. Upload client-side writes to your backend API. Any writes that are made to the SQLite database are placed into an upload queue by the PowerSync Client SDK and automatically uploaded to your app backend (where you apply those changes to the backend source database) when the user is connected.

Accordingly, the connector must implement two methods:

1. PowerSyncBackendConnectorProtocol.fetchCredentials - This method is automatically invoked by the PowerSync Client SDK to obtain authentication credentials. The SDK caches credentials internally and only calls this method when needed (e.g. on initial connection or when the token is near expiry). See When fetchCredentials() is Called for details, and Authentication Setup for instructions on how the credentials should be generated.

2. PowerSyncBackendConnectorProtocol.uploadData - This method will be automatically invoked by the PowerSync Client SDK whenever it needs to upload client-side writes to your app’s backend API. You need to implement how those writes are processed and uploaded in this method. See When uploadData() is Called for details on triggers, throttling, and retry behavior, and Writing Client Changes for considerations on the app backend implementation.

Example:

import PowerSync

final class MyConnector: PowerSyncBackendConnectorProtocol {
    func fetchCredentials() async throws -> PowerSyncCredentials? {
        // implement fetchCredentials to obtain the necessary credentials to connect to your backend
        // See an example implementation in https://github.com/powersync-ja/powersync-swift/blob/main/Demo/PowerSyncExample/PowerSync/SupabaseConnector.swift
        return PowerSyncCredentials(
            endpoint: "Your PowerSync instance URL or self-hosted endpoint",
            // Use a development token (see Authentication Setup https://docs.powersync.com/configuration/auth/development-tokens)
            // to get up and running quickly
            token: "An authentication token"
        )
    }

    func uploadData(database: PowerSyncDatabaseProtocol) async throws {
        // Implement uploadData to send local changes to your backend service
        // You can omit this method if you only want to sync data from the server to the client
        // See an example implementation under Usage Examples (sub-page)
        // See https://docs.powersync.com/handling-writes/writing-client-changes for considerations.
    }
}

Connect the PowerSync database to sync data with your backend:

let connector = MyConnector()

try await powerSync.connect(connector: connector)

Note: This section assumes you want to use PowerSync to sync your backend source database with SQLite in your app. If you only want to use PowerSync to manage your local SQLite database without sync, instantiate the PowerSync database without calling connect() and refer to our Local-Only guide.

Using PowerSync: CRUD functions

Once the PowerSync instance is configured you can start using the SQLite DB functions.

The most commonly used CRUD functions to interact with your SQLite data are:

• PowerSyncDatabase.get - get (SELECT) a single row from a table.

• PowerSyncDatabase.getOptional - get (SELECT) a single row from a table and return null if not found.

• PowerSyncDatabase.getAll - get (SELECT) a set of rows from a table.

• PowerSyncDatabase.watch - execute a read query every time source tables are modified.

• PowerSyncDatabase.execute - execute a write (INSERT/UPDATE/DELETE) query.

Fetching a Single Item (PowerSync.get / PowerSync.getOptional)

The get method executes a read-only (SELECT) query and returns a single result. It throws an exception if no result is found. Use getOptional to return a single optional result (returns null if no result is found).

// Find a list item by ID
func getList(_ id: String) async throws {
    try await self.db.getAll(
        sql: "SELECT * FROM \(LISTS_TABLE) WHERE id = ?",
        parameters: [id],
        mapper: { cursor in
            ListContent(
                id: try cursor.getString(name: "id")!,
                name: try cursor.getString(name: "name")!,
                createdAt: try cursor.getString(name: "created_at")!,
                ownerId: try cursor.getString(name: "owner_id")!
            )
        }
    )
}

Querying Items (PowerSync.getAll)

The getAll method executes a read-only (SELECT) query and returns a set of rows.

// Get all lists
func getLists() async throws {
    try await self.db.getAll(
        sql: "SELECT * FROM \(LISTS_TABLE)",
        parameters: [],
        mapper: { cursor in
            ListContent(
                id: try cursor.getString(name: "id")!,
                name: try cursor.getString(name: "name")!,
                createdAt: try cursor.getString(name: "created_at")!,
                ownerId: try cursor.getString(name: "owner_id")!
            )
        }
    )
}

Watching Queries (PowerSync.watch)

The watch method executes a read query whenever a change to a dependent table is made.

func watchPendingLists() throws -> AsyncThrowingStream<[ListContent], Error> {
    try db.watch(
        sql: "SELECT * FROM lists WHERE state = ?",
        parameters: ["pending"],
    ) { cursor in
        try ListContent(
            id: cursor.getString(name: "id"),
            name: cursor.getString(name: "name"),
        )
    }
}

Mutations (PowerSync.execute)

The execute method executes a write query (INSERT, UPDATE, DELETE) and returns the results (if any).

func insertTodo(_ todo: NewTodo, _ listId: String) async throws {
    try await db.execute(
        sql: "INSERT INTO \(TODOS_TABLE) (id, created_at, created_by, description, list_id, completed) VALUES (uuid(), datetime(), ?, ?, ?, ?)",
        parameters: [connector.currentUserID, todo.description, listId, todo.isComplete]
    )
}

func updateTodo(_ todo: Todo) async throws {
    try await db.execute(
        sql: "UPDATE \(TODOS_TABLE) SET description = ?, completed = ?, completed_at = datetime(), completed_by = ? WHERE id = ?",
        parameters: [todo.description, todo.isComplete, connector.currentUserID, todo.id]
    )
}

func deleteTodo(id: String) async throws {
    try await db.writeTransaction(callback: { transaction in
        _ = try transaction.execute(
                sql: "DELETE FROM \(TODOS_TABLE) WHERE id = ?",
                parameters: [id]
            )
    })
}

Configure Logging

You can include your own Logger that must conform to the LoggerProtocol as shown here.

let logger = DefaultLogger(minSeverity: .debug)
let db = PowerSyncDatabase(
    schema: schema,
    dbFilename: "powersync-swift.sqlite",
    logger: logger
)

The DefaultLogger supports the following severity levels: .debug, .info, .warn, .error.

Custom HTTP Clients and Headers

PowerSync uses a streaming HTTP response to connect to the PowerSync service. By default, the Swift SDK uses URLSession.shared to run HTTP requests.

You can provide a custom URLSession as a sync option. This can be used to add custom HTTP headers, for example:

let config = URLSessionConfiguration.ephemeral
config.httpAdditionalHeaders = ["x-my-custom-header": "example"]
let session = URLSession(configuration: config)

try await db.connect(
    connector: connector,
    options: ConnectOptions(
        clientConfiguration: SyncClientConfiguration(
            urlSession: session
        )
    )
)

For more information, see Apple’s documentation on URLSessionConfiguration.

Additional Usage Examples

For more usage examples including accessing connection status, monitoring sync progress, and waiting for initial sync, see the Usage Examples page.

ORM Support

PowerSync officially supports the GRDB library for Swift.

Additionally, Asier G. Morato contributed a Swift Data integration for PowerSync, allowing Swift Data models to be persisted and synced through a PowerSync database. Note that the integration is community-owned and not officially supported by PowerSync.

Troubleshooting

See Troubleshooting for pointers to debug common issues.

Supported Platforms

See Supported Platforms -> Swift SDK.

Upgrading the SDK

Update the version number in Package.swift or via Xcode Package Dependencies as documented in the installation instructions: Installation.

Upgrading to v1.14: This release removes the internal Kotlin dependency and re-implements the SQLite connection pool logic natively in Swift. The public API is unchanged, but the internals are a full rewrite. We recommend testing queries in your app after upgrading to this version.