Instalar el SDK en Swift

Entorno mínimo	iOS 15+ · macOS 12+
Distribución	Swift Package Manager, desde el repositorio de Git

Lo que necesitas antes de empezar

• Acceso al repositorio de Git, por SSH o por la cuenta configurada en Xcode.
• Un session_id de prueba, creado por tu backend, por el monto mínimo.
• Datos de un pagador real: cédula, teléfono y banco venezolanos, asociados entre sí.

Paso 1 · Configura Xcode o tu SSH

Añade el paquete desde la interfaz de Xcode, o declara la dependencia en tu Package.swift:

dependencies: [
    .package(url: "https://bitbucket.org/summabit/spidi-sdk-swift.git", from: "0.2.0"),
],
targets: [
    .target(
        name: "MiApp",
        dependencies: [
            .product(name: "Spidi", package: "spidi-sdk-swift")
        ]
    )
]

Paso 2 · Tu primera llamada

import Foundation
import Spidi

let client = SpidiClient(options: ClientOptions(
    environment: .sandbox, // .sandbox o .production
    timeout: 30
))

Task {
    do {
        let sessionResponse = try await client.getSession("tu_session_id")
        if client.isPaidSession(sessionResponse) {
            print("El pago de esta sesión ya se completó")
            return
        }

        let amounts = Amounts(session: sessionResponse.data)
        print("Total: Bs. \\(amounts.bsFormatted)  (USD \\(amounts.usdFormatted))")
    } catch {
        print("Error de inicialización del SDK: \\(error)")
    }
}

Paso 3 · El flujo del débito inmediato

3.1 — Prepara los datos

let identification = buildIdentification(.cedula, "12345678") // V12345678
let instrument = buildInstrument("0412", "1234567")             // 04121234567
let bank = try await client.getBanks().first { $0.code == "0102" }!

let pos = try await client.getPosCommerce(alias: session.posCommerceAlias)

let tx = try await client.createTransaction(
    CreateTransactionInput(
        identification: identification,
        amount: formatBsAmount(session.bsAmount), // "10,00" (con coma)
        bankCode: bank.code,                      // "0102"
        instrument: instrument,                   // teléfono del pagador
        posCommerceId: pos.data.id
    )
)

3.2 — Crea la transacción y persístela antes de confirmar

let transaction = SpidiTransaction(
    transactionId: tx.transactionId,
    usdAmount: session.usdAmount,
    bsAmount: session.bsAmount,
    bcvRate: session.bcvRate,
    payerPaymentId: identification,
    payerPaymentPhone: instrument,
    bankId: bank.id, // UUID del banco
    spidiSessionId: session.id,
    spidiCommerceAlias: session.spidiCommerceAlias,
    posCommerceAlias: session.posCommerceAlias,
    mainCurrency: session.mainCurrency,
    spidiId: tx.spidiId
)

try await client.saveSession(
    SaveSessionInput(
        id: session.id,
        usdAmount: transaction.usdAmount,
        bsAmount: transaction.bsAmount,
        bcvRate: transaction.bcvRate,
        spidiCommerceAlias: transaction.spidiCommerceAlias,
        posCommerceAlias: transaction.posCommerceAlias,
        mainCurrency: transaction.mainCurrency,
        transactionId: transaction.transactionId,
        payerPaymentId: transaction.payerPaymentId,
        payerPaymentPhone: transaction.payerPaymentPhone,
        bankId: transaction.bankId,
        spidiId: transaction.spidiId
    )
)

3.3 — Confirma el débito. Aquí sale el dinero:

do {
    let result = try await client.confirmPayment(
        transactionID: tx.transactionId,
        key: "clave_dinamica_SMS",
        transaction: transaction
    )
    if let rejection = result.rejection {
        print("El banco rechazó la transacción: \\(rejection.codeId) · \\(rejection.userDescription ?? "")")
        return
    }
    print("¡Pago confirmado! Comprobante: \\(result.id ?? "")")
} catch {
    // IMPORTANTE: Si ocurre un timeout o error de conexión, NUNCA repitas el envío.
    // Consulta el estado real del pago para verificar si el débito se efectuó:
    let status = try? await client.getTransactionStatus(sessionID: session.id)
    print("Confirmación con respuesta ambigua: \\(error). Estado en API: \\(String(describing: status?.status))")
}

Cripto vía Binance Pay

// Crear la orden cripto
let order = try await client.createCryptoOrder(sessionID: session.id, amountVES: session.bsAmount)

// Acreditar el pago una vez que el procesador lo valide
let status = try await client.getCryptoOrderStatus(orderID: order.crixtoOrderId)
if status == "PAID" {
    let result = try await client.confirmCryptoPayment(
        orderID: order.crixtoOrderId,
        input: CryptoConfirmationInput(...)
    )
}

→ Cripto con Binance Pay

Las reglas que no cambian entre plataformas

Los formatos de monto, los dos identificadores del banco, la validación y —sobre todo— la regla de que la confirmación del débito no se reintenta nunca son idénticos en las cuatro. Viven en una sola página para que no se lean a medias:

→ El contrato y los errores · Antes de tocar dinero real

De dónde sale este código

Del documento de integración que entrega SPIDI, de agosto de 2026, copiado literal. No lo hemos ejecutado: el paquete es privado y no tenemos acceso. A diferencia del resto de este portal, aquí no hay una prueba que lo respalde.