# Get Account
Source: https://docs.bridge.com.do/api-reference/endpoint/get-account

get /accounts/{accountId}
Buscar una cuenta por su ID.



# Get Connection
Source: https://docs.bridge.com.do/api-reference/endpoint/get-connection

get /connections/{connectionId}
Buscar una conexión por su ID.



# Get Transaction
Source: https://docs.bridge.com.do/api-reference/endpoint/get-transaction

get /accounts/{accountId}/transactions/{transactionId}
Buscar una transacción por su identificador.



# List Accounts
Source: https://docs.bridge.com.do/api-reference/endpoint/list-accounts

get /connections/{connectionId}/accounts
Listar cuentas asociadas a una conexión.



# List Connections
Source: https://docs.bridge.com.do/api-reference/endpoint/list-connections

get /connections
Listar conexiones segun el acceso actual (Scoped Token)



# List Transactions
Source: https://docs.bridge.com.do/api-reference/endpoint/list-transactions

get /accounts/{accountId}/transactions
Listar todas las transacciones de una cuenta.



# Revoke Connection
Source: https://docs.bridge.com.do/api-reference/endpoint/revoke-connection

delete /connections/{connectionId}
Revocar una conexión, impidiendo accesos futuros. <Warning>Al revocar la conexión se dejará de actualizar su información relacionada, como balances de cuentas e historial de transacciones. Estos datos estarán disponibles por un periodo de 30 dias luego de la revocación. Luego de este periodo, los datos serán eliminados.</Warning>



# Consultar Balances y Transacciones
Source: https://docs.bridge.com.do/guides/accounts-transactions

Cómo obtener información de cuentas bancarias conectadas

## Introducción

Una vez que tus usuarios han conectado sus cuentas bancarias usando Bridge Connect, puedes acceder a sus balances actuales y el historial completo de transacciones.

Esta guía asume que ya tienes el `connectionId` y `scopedToken` del paso anterior de [integrar Bridge Connect](/guides/connect).

## Autenticación

Todas las solicitudes en esta guía requieren ambas credenciales de acceso. Para una explicación detallada de cada una, consulta la [guía de autenticación](/guides/authentication).

| Header           | Valor                        |
| ---------------- | ---------------------------- |
| `Authorization`  | `Bearer <tu_clave_de_api>`   |
| `X-Scoped-Token` | `<token_de_acceso_limitado>` |

## Listar Cuentas

Para obtener todas las cuentas asociadas a una conexión, utiliza el endpoint de lista de cuentas:

```bash theme={null}
curl https://api.bridge.com.do/connections/{connectionId}/accounts \
  -H "Authorization: Bearer <api_key>" \
  -H "X-Scoped-Token: <scoped_token>"
```

### Respuesta

```json theme={null}
{
  "accounts": [
    {
      "id": "acc_zP2oiEAvu7LnuUVc",
      "connectionId": "con_JNhdJbLyi55gZAUW",
      "type": "depository",
      "name": "Cuenta de Ahorros",
      "lastFour": "1234",
      "balance": {
        "current": 150000.5,
        "available": 150000.5
      },
      "currency": "DOP",
      "lastTransactionRefresh": "txr_01J8XGKZP8K9V7J552EPPD89HM"
    },
    {
      "id": "acc_8kLmN3qR9vTxYzAb",
      "connectionId": "con_JNhdJbLyi55gZAUW",
      "type": "credit",
      "name": "Tarjeta de Crédito Visa",
      "lastFour": "5678",
      "balance": {
        "current": -25000.0,
        "available": 75000.0,
        "limit": 100000.0
      },
      "currency": "DOP",
      "lastTransactionRefresh": "txr_01J8XGKZP8K9V7J552EPPD89HM"
    }
  ]
}
```

Ver detalles completos de la respuesta en la [referencia del endpoint](/api-reference/endpoint/list-accounts).

## Obtener Detalles de una Cuenta

Si necesitas información de una cuenta específica:

```bash theme={null}
curl https://api.bridge.com.do/accounts/{accountId} \
  -H "Authorization: Bearer <api_key>" \
  -H "X-Scoped-Token: <scoped_token>"
```

Ver detalles completos de la respuesta en la [referencia del endpoint](/api-reference/endpoint/get-account).

## Listar Transacciones

Para obtener el historial de transacciones de una cuenta:

```bash theme={null}
curl https://api.bridge.com.do/accounts/{accountId}/transactions \
  -H "Authorization: Bearer <api_key>" \
  -H "X-Scoped-Token: <scoped_token>"
```

### Respuesta

```json theme={null}
{
  "transactions": [
    {
      "id": "txn_ckB4a8Ly6PojhwoT",
      "accountId": "acc_zP2oiEAvu7LnuUVc",
      "amount": -5000.0,
      "date": "2024-01-15",
      "description": "Compra en Supermercado Nacional",
      "reference": "REF123456",
      "status": "posted",
      "transactionRefresh": "txr_01J8XGKZP8K9V7J552EPPD89HM"
    },
    {
      "id": "txn_9xYzAb3cDeFgHiJk",
      "accountId": "acc_zP2oiEAvu7LnuUVc",
      "amount": 50000.0,
      "date": "2024-01-14",
      "description": "Depósito Nómina",
      "reference": "DEP987654",
      "status": "posted",
      "transactionRefresh": "txr_01J8XGKZP8K9V7J552EPPD89HM"
    }
  ]
}
```

### Filtrar por Fecha

Puedes filtrar transacciones por rango de fechas usando los siguientes parámetros:

```bash theme={null}
# Transacciones desde el 1 de enero de 2024
curl "https://api.bridge.com.do/accounts/{accountId}/transactions?date[gte]=2024-01-01" \
  -H "Authorization: Bearer <api_key>" \
  -H "X-Scoped-Token: <scoped_token>"

# Transacciones entre dos fechas
curl "https://api.bridge.com.do/accounts/{accountId}/transactions?date[gte]=2024-01-01&date[lte]=2024-01-31" \
  -H "Authorization: Bearer <api_key>" \
  -H "X-Scoped-Token: <scoped_token>"
```

Operadores de fecha disponibles:

* `date[gte]` - Mayor o igual que (desde)
* `date[lte]` - Menor o igual que (hasta)
* `date[gt]` - Mayor que (después de)
* `date[lt]` - Menor que (antes de)

### Filtrar por Actualización

Para obtener solo las transacciones que han sido creadas o actualizadas desde tu última consulta, utiliza el cursor `refreshedSince`:

```bash theme={null}
curl "https://api.bridge.com.do/accounts/{accountId}/transactions?refreshedSince=txr_01J8XGKZP8K9V7J552EPPD89HM" \
  -H "Authorization: Bearer <api_key>" \
  -H "X-Scoped-Token: <scoped_token>"
```

Este cursor se obtiene del campo `lastTransactionRefresh` en la respuesta de cuentas, o del campo `transactionRefresh` de cualquier transacción.

Ver más detalles sobre filtros y la respuesta en la [referencia del endpoint](/api-reference/endpoint/list-transactions).

## Obtener Detalles de una Transacción

Para consultar una transacción específica:

```bash theme={null}
curl https://api.bridge.com.do/accounts/{accountId}/transactions/{transactionId} \
  -H "Authorization: Bearer <api_key>" \
  -H "X-Scoped-Token: <scoped_token>"
```

Ver detalles completos de la respuesta en la [referencia del endpoint](/api-reference/endpoint/get-transaction).

## Ejemplo Completo en JavaScript

```javascript theme={null}
const API_KEY = "tu_api_key";
const SCOPED_TOKEN = "brdg_st_xxxxx"; // Token del usuario
const CONNECTION_ID = "con_JNhdJbLyi55gZAUW";
const BASE_URL = "https://api.bridge.com.do";

// Función auxiliar para hacer requests
async function bridgeRequest(endpoint, scopedToken = null) {
  const headers = {
    Authorization: `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
  };

  if (scopedToken) {
    headers["X-Scoped-Token"] = scopedToken;
  }

  const response = await fetch(`${BASE_URL}${endpoint}`, { headers });

  if (!response.ok) {
    throw new Error(`Error ${response.status}: ${await response.text()}`);
  }

  return response.json();
}

// 1. Listar todas las cuentas de una conexión
async function getAccounts(connectionId, scopedToken) {
  const data = await bridgeRequest(
    `/connections/${connectionId}/accounts`,
    scopedToken,
  );
  return data.accounts;
}

// 2. Obtener transacciones de una cuenta
async function getTransactions(accountId, scopedToken, filters = {}) {
  let endpoint = `/accounts/${accountId}/transactions`;

  // Agregar filtros opcionales
  const params = new URLSearchParams();
  if (filters.dateFrom) params.append("date[gte]", filters.dateFrom);
  if (filters.dateTo) params.append("date[lte]", filters.dateTo);
  if (filters.refreshedSince)
    params.append("refreshedSince", filters.refreshedSince);

  if (params.toString()) {
    endpoint += `?${params.toString()}`;
  }

  const data = await bridgeRequest(endpoint, scopedToken);
  return data.transactions;
}

// Uso del ejemplo
(async () => {
  try {
    // Obtener cuentas
    const accounts = await getAccounts(CONNECTION_ID, SCOPED_TOKEN);
    console.log(`Encontradas ${accounts.length} cuentas:`);

    accounts.forEach((account) => {
      console.log(`\n${account.name} (${account.lastFour})`);
      console.log(`  Balance: ${account.balance.current} ${account.currency}`);
      if (account.balance.available) {
        console.log(
          `  Disponible: ${account.balance.available} ${account.currency}`,
        );
      }
    });

    // Obtener transacciones de la primera cuenta
    if (accounts.length > 0) {
      const accountId = accounts[0].id;

      // Últimos 30 días
      const dateFrom = new Date();
      dateFrom.setDate(dateFrom.getDate() - 30);

      const transactions = await getTransactions(accountId, SCOPED_TOKEN, {
        dateFrom: dateFrom.toISOString().split("T")[0],
      });

      console.log(`\n\nÚltimas transacciones de ${accounts[0].name}:`);
      transactions.slice(0, 10).forEach((tx) => {
        const type = tx.amount > 0 ? "Ingreso" : "Egreso";
        console.log(
          `${tx.date.split("T")[0]} | ${type} | ${Math.abs(tx.amount)} | ${tx.description}`,
        );
      });
    }
  } catch (error) {
    console.error("Error:", error.message);
  }
})();
```

## Manejo de Errores

Los códigos de error comunes incluyen:

* **`401 Unauthorized`** - API Key inválida o faltante
* **`403 Forbidden`** - Scoped Token inválido o sin permisos para acceder a este recurso
* **`404 Not Found`** - Conexión, cuenta o transacción no encontrada

Siempre implementa manejo de errores apropiado en tu aplicación para brindar una buena experiencia a tus usuarios.

## Próximos Pasos

* Explora la [referencia completa de la API](/api-reference)
* Revisa cómo [revocar conexiones](/api-reference/endpoint/revoke-connection) cuando los usuarios lo soliciten


# Autenticación
Source: https://docs.bridge.com.do/guides/authentication

Cómo autenticar tus solicitudes a la API de Bridge

## Introducción

Bridge utiliza dos mecanismos de autenticación que trabajan en conjunto para proteger los datos financieros de tus usuarios. Esta arquitectura de doble autenticación garantiza que solo tu aplicación pueda acceder a los datos, y que cada solicitud esté limitada únicamente a los recursos autorizados.

## Clave de API (API Key)

La Clave de API identifica tu aplicación ante Bridge. Es una credencial secreta que demuestra que las solicitudes provienen de tu servidor autorizado.

### Cómo obtenerla

1. Accede al [Dashboard de Bridge](https://dash.bridge.com.do)
2. Selecciona tu organización y aplicación
3. Ve a la sección **Llaves de acceso** en el menú lateral
4. Haz clic en **+ Nueva llave** para crear una nueva clave

Cada aplicación pertenece a un entorno específico (Sandbox o Producción). Para probar en Sandbox, crea una aplicación de prueba; para producción, usa una aplicación de producción.

### Cómo usarla

Incluye tu Clave de API en el header `Authorization` de cada solicitud:

```bash theme={null}
curl https://api.bridge.com.do/connections/con_xxxx \
  -H "Authorization: Bearer <tu_clave_de_api>"
```

### Alcance

La Clave de API te da acceso a nivel de aplicación. Con ella puedes realizar operaciones administrativas como consultar o revocar conexiones específicas por su ID, sin necesidad de credenciales adicionales.

***

## Token de Acceso Limitado (Scoped Token)

El Token de Acceso Limitado es una credencial que restringe el acceso a un subconjunto específico de recursos. A diferencia de la Clave de API que identifica tu aplicación, este token determina *a qué datos de usuario* puedes acceder.

### Por qué existe

Los datos financieros sensibles (números de cuenta, balances, transacciones) están encriptados en Bridge. La información de cada usuario está encriptada de forma independiente, y el Token de Acceso Limitado contiene la llave criptográfica necesaria para descifrar únicamente los datos de ese usuario.

Esta arquitectura garantiza que:

* Bridge no puede acceder a los datos sin tu token
* Si pierdes el token, los datos permanecen inaccesibles, protegiendo ante posibles brechas de seguridad
* Cada token está matemáticamente vinculado a un usuario específico

Es importante notar que el Token de Acceso Limitado por sí solo no es suficiente para acceder a la API. Siempre debe estar acompañado de una Clave de API válida de la misma aplicación. Esta combinación garantiza que solo tu servidor autorizado puede descifrar los datos de tus usuarios.

### Alcance del token

El alcance del token depende de cómo configuraste Bridge Connect:

**Por defecto (sin `externalUserId`):** El token da acceso únicamente a la conexión creada en esa sesión. Cada nueva conexión genera un token independiente.

**Con `externalUserId`:** El token da acceso a *todas* las conexiones del usuario identificado. Solo recibes el token en la primera conexión del usuario; conexiones subsecuentes usan el mismo token.

Para verificar a qué conexiones tiene acceso un token, consulta el endpoint de listar conexiones:

```bash theme={null}
curl https://api.bridge.com.do/connections \
  -H "Authorization: Bearer <tu_clave_de_api>" \
  -H "X-Scoped-Token: <token_de_acceso>"
```

### Cómo obtenerlo

El token se retorna en el evento `onSuccess` de [Bridge Connect](/guides/connect) cuando el usuario completa la vinculación de su cuenta:

```javascript theme={null}
BridgeConnect.init({
  applicationId: "app_xxx",
  onSuccess: function ({ connectionId, scopedToken }) {
    // scopedToken contiene el Token de Acceso Limitado
    // Guárdalo de forma segura en tu backend
  },
});
```

<Warning>
  El token solo se retorna una vez. Si lo pierdes, no hay forma de recuperarlo y
  el usuario deberá reconectar su cuenta.
</Warning>

### Cómo usarlo

Incluye el token en el header `X-Scoped-Token`:

```bash theme={null}
curl https://api.bridge.com.do/accounts/acc_xxx \
  -H "Authorization: Bearer <tu_clave_de_api>" \
  -H "X-Scoped-Token: <token_de_acceso>"
```

***

## Cuándo usar cada credencial

La regla general es simple: **las operaciones que acceden a datos sensibles del usuario requieren ambas credenciales**, mientras que las operaciones administrativas solo requieren la Clave de API.

| Operación                   | Clave de API | Token de Acceso Limitado |
| --------------------------- | :----------: | :----------------------: |
| Obtener una conexión por ID |       ✓      |             —            |
| Revocar una conexión        |       ✓      |             —            |
| Listar conexiones del token |       ✓      |             ✓            |
| Listar cuentas              |       ✓      |             ✓            |
| Obtener detalles de cuenta  |       ✓      |             ✓            |
| Listar transacciones        |       ✓      |             ✓            |
| Obtener una transacción     |       ✓      |             ✓            |

### Ejemplos de uso

**Solo Clave de API** — Revocar una conexión cuando el usuario lo solicita:

```bash theme={null}
curl -X DELETE https://api.bridge.com.do/connections/con_xxx \
  -H "Authorization: Bearer <tu_clave_de_api>"
```

**Ambas credenciales** — Obtener el balance actual de una cuenta:

```bash theme={null}
curl https://api.bridge.com.do/accounts/acc_xxx \
  -H "Authorization: Bearer <tu_clave_de_api>" \
  -H "X-Scoped-Token: <token_de_acceso>"
```

***

## Seguridad

<Warning>
  **Nunca expongas tus credenciales en código del lado del cliente.** Todas las
  llamadas a la API de Bridge deben realizarse desde tu servidor backend.
</Warning>

### Mejores prácticas

* **Almacena las credenciales de forma segura** — Usa variables de entorno o un gestor de secretos. Nunca las incluyas directamente en el código.

* **Asocia el token al usuario** — Guarda el Token de Acceso Limitado en tu base de datos, vinculado al usuario correspondiente, para poder realizar consultas futuras.

* **No registres credenciales en logs** — Evita incluir tokens o claves en mensajes de log o reportes de error.

* **Usa siempre HTTPS** — Todas las comunicaciones con la API de Bridge deben ser a través de conexiones seguras.

* **Responde ante compromisos** — Si sospechas que una credencial fue expuesta, genera una nueva Clave de API desde el dashboard.

## Errores comunes

| Código             | Significado                                                                 |
| ------------------ | --------------------------------------------------------------------------- |
| `401 Unauthorized` | Clave de API inválida o faltante                                            |
| `403 Forbidden`    | Token de Acceso Limitado inválido o sin permisos para el recurso solicitado |

***

## Próximos pasos

* [Integrar Bridge Connect](/guides/connect) para obtener tokens de tus usuarios
* [Consultar balances y transacciones](/guides/accounts-transactions) usando tus credenciales


# Bridge Connect
Source: https://docs.bridge.com.do/guides/connect

Cómo integrar Bridge Connect a tu aplicación

<video />

## Introducción

Bridge Connect facilita la integración de Bridge a tu aplicación. En cuestión de minutos podrás agregarle a tu aplicación la habilidad de que tus usuarios conecten sus cuentas bancarias.

Implementando Bridge Connect obtienes validación de credenciales, autenticación de multi-factor, y selección de cuentas bancarias.

## Web

Para integrar Bridge Connect en tu aplicación web, simplemente agrega el siguiente script en tu página:

```html theme={null}
<script src="https://static.bridge.com.do/connect/bridge-connect.js"></script>
```

Recomendamos colocar el script al final del `body` de tu página web para que la carga de tu página no se vea afectada.

Luego, inicializa Bridge Connect con el ID de tu aplicación:

```javascript theme={null}
const bridgeConnect = BridgeConnect.init({
  applicationId: "<app_id>",
  externalUserId: "user_123", // Opcional: ID de usuario de tu sistema
});
```

El ID de tu aplicación lo puedes encontrar en la sección de configuración de tu aplicación en el [dashboard](https://dash.bridge.com.do/apps).

Cuando estés listo para abrir Bridge Connect, simplemente llama al método `open`:

```javascript theme={null}
bridgeConnect.open();
```

### Identificación de Usuarios

Puedes pasar un `externalUserId` (opcional) para asociar múltiples conexiones al mismo usuario. Esto permite:

* Acceder a todas las conexiones de un usuario final con un único token
* Listar todas las conexiones de un usuario mediante la API

Si no proporcionas un `externalUserId`, se creará un usuario anónimo y cada conexión requerirá su propio token.

### Eventos

Bridge Connect emite eventos que puedes escuchar para saber cuándo el usuario ha completado la conexión, o si ha cerrado Bridge Connect. Puedes escuchar estos eventos pasando funciones para `onInit`, `onSuccess`, y `onExit` al configurar Bridge Connect.

* `onSuccess`: Se ejecuta cuando el usuario ha completado la conexión, y recibe un objeto con:
  * `connectionId`: ID de la conexión creada
  * `accounts`: Arreglo de cuentas conectadas
  * `institution`: Información del banco
  * `user`: (Opcional) Información del usuario si proporcionaste `externalUserId`
  * `scopedToken`: (Opcional) **Solo se retorna en la primera conexión del usuario**. Este es el [Token de Acceso Limitado](/guides/authentication#token-de-acceso-limitado-scoped-token), necesario para descifrar y acceder a los datos sensibles de las cuentas conectadas. En conexiones subsecuentes del mismo usuario, debes usar el token original.
* `onInit`: Se ejecuta cuando Bridge Connect ha sido inicializado.
* `onExit`: Se ejecuta cuando el usuario ha cerrado Bridge Connect, abandonando el flujo de conexión.

Todas las funciones son opcionales.

<Warning>
  **Importante**: El [Token de Acceso Limitado](/guides/authentication#token-de-acceso-limitado-scoped-token) (`scopedToken`) solo se retorna la primera vez que un usuario (identificado por `externalUserId`) conecta una cuenta. En conexiones adicionales del mismo usuario, no se retorna un nuevo token. Debes almacenar el token de forma segura en la primera conexión.

  Para usuarios anónimos (sin `externalUserId`), cada conexión es tratada como un nuevo usuario y siempre recibirás un `scopedToken`.
</Warning>

### Reconectar una cuenta

Si las credenciales de una conexión expiran o se vuelven inválidas, puedes usar Bridge Connect para reconectar la cuenta sin crear una nueva conexión. Simplemente pasa el `connectionId` junto con el `applicationId`:

```javascript theme={null}
const bridgeConnect = BridgeConnect.init({
  applicationId: "app_*****",
  connectionId: "con_*****", // ID de la conexión a reconectar
  onSuccess: function ({ connectionId }) {
    console.log("Conexión restaurada:", connectionId);
    // Nota: No se retorna un scopedToken en reconexiones
  },
});

bridgeConnect.open();
```

Al reconectar:

* El usuario solo necesita ingresar sus credenciales bancarias
* Se omiten los pasos de selección de banco y cuentas
* El `scopedToken` original sigue siendo válido (no se retorna uno nuevo)
* Se verifican las cuentas para asegurar que corresponden a la conexión original

### Ejemplo completo

```html theme={null}
<!doctype html>
<html>
  <head>
    <title>Bridge Connect</title>
  </head>
  <body>
    <h1>Bridge Connect Demo</h1>
    <!-- Botón para abrir Bridge Connect -->
    <button id="connect">Conectar cuentas</button>

    <!-- [ Contenido de tu página ] -->

    <!-- Script de Bridge Connect -->
    <script src="https://static.bridge.com.do/connect/bridge-connect.js"></script>

    <!-- Inicializar y configurar Bridge Connect -->
    <script>
      document.addEventListener("DOMContentLoaded", function () {
        var bridgeConnect = BridgeConnect.init({
          applicationId: "app_*****",
          externalUserId: "user_123", // ID del usuario en tu sistema
          onInit: function () {
            console.log("Bridge Connect ha sido inicializado");
          },
          onSuccess: function ({
            connectionId,
            accounts,
            institution,
            user,
            scopedToken,
          }) {
            console.log("Conexión creada:", connectionId);
            console.log("Banco:", institution.name);
            console.log("Cuentas conectadas:", accounts.length);

            // Solo se recibe scopedToken en la primera conexión del usuario
            if (scopedToken) {
              console.log("Scoped token (primera conexión):", scopedToken);
            } else {
              console.log("Conexión adicional - usa el token existente");
            }

            if (user) {
              console.log("Usuario:", user.id, user.externalUserId);
            }
          },
          onExit: function () {
            console.log("El usuario ha cerrado Bridge Connect");
          },
        });

        // Agregar evento al botón para abrir Bridge Connect
        document
          .getElementById("connect")
          .addEventListener("click", function () {
            bridgeConnect.open();
          });
      });
    </script>
  </body>
</html>
```

## Otras plataformas

Tenemos SDKs para React y React Native disponibles, y estamos trabajando en SDKs nativos para iOS y Android. Si estás interesado, contáctanos para ayudar a priorizar compatiblidad para tu caso de uso.


# Introducción
Source: https://docs.bridge.com.do/intro

Descubre nuestras guías y recursos para integrar Bridge a tu aplicación

Bridge es una plataforma que facilita la conexión de cuentas bancarias a aplicaciones financieras. Con Bridge, puedes obtener información financiera de tus usuarios, como balances de cuentas, transacciones, etc.

<CardGroup>
  <Card title="Bridge Connect" icon="link" href="/guides/connect">
    Integra el widget de Bridge Connect a tu aplicación para que tus usuarios
    conecten sus cuentas bancarias.
  </Card>

  <Card title="Bridge API" icon="code" href="/guides/accounts-transactions">
    Consume información financiera de tus usuarios a través de la API de Bridge.
  </Card>
</CardGroup>