> ## Documentation Index
> Fetch the complete documentation index at: https://help.dash.fi/llms.txt
> Use this file to discover all available pages before exploring further.

# List card transactions

> Retrieves a paginated list of card transactions for the authenticated account. Each entry's `id` matches the `transactionId` field emitted on card financial event webhooks, so webhook deliveries and API rows can be reconciled directly. Returned in reverse chronological order by `createdAt`.

If both pagination parameters are not provided, a default of page 1 with size 100 is used. Max page size is 100. For post-settlement reconciliation against payment cycles, see `/settlements`.



## OpenAPI

````yaml https://api.dash.fi/v1/public/swagger/doc.json get /transactions
openapi: 3.1.0
info:
  contact:
    email: support@dash.fi
    name: Dash.fi Support
  description: >-
    Service allows to fetch or operate on the data from the Dash.fi API.
    Requires API key authentication via Bearer token.

    Provide your API key as a Bearer token in the `Authorization` header.
    Example: `Authorization: Bearer YOUR_API_KEY`
  title: Public Dash.fi API
  version: '1.0'
servers:
  - url: https://api.dash.fi/v1/public
security:
  - BearerAuth: []
tags:
  - description: >
      Subscribe URLs to receive POSTed events as they happen in your account.
      Each endpoint subscribes to one or more **topics**; when a topic fires,
      Dash.fi delivers the event to your URL with a JSON body matching the
      topic's payload schema. There is no envelope — the body is the event
      payload directly. Event metadata (id, topic, timestamp, signature) is
      carried in headers.


      ### Topic → payload schema


      Topics are versioned: the format is `<domain>.<event>.v<major>`. Breaking

      changes ship as a **new** topic (`.v2`) — the old version keeps delivering
      its

      existing schema until it's retired, so subscriptions are pinned and never

      shift schema underneath you.


      | Topic | Body schema |

      |---|---|

      | `card.financial_event.v1` | `CardFinancialEvent` — see `GET
      /cards/{id}/financial-events` in the **Card** section for the
      authoritative field list. |


      ### Delivery shape


      ```

      POST <your URL> HTTP/1.1

      Content-Type: application/json

      X-Outpost-Event-Id: evt_abc123

      X-Outpost-Topic: card.financial_event.v1

      X-Outpost-Timestamp: 2026-05-05T10:00:00Z

      X-Outpost-Signature: v0=<hex hmac-sha256>


      { ...payload matching the topic's schema... }

      ```


      | Header | Meaning |

      |---|---|

      | `X-Outpost-Event-Id` | Stable event identifier — the same id is sent on
      retries. Use it to deduplicate; delivery is **at-least-once**. |

      | `X-Outpost-Topic` | The topic that fired this delivery. |

      | `X-Outpost-Timestamp` | RFC 3339 time the event was emitted. Reject
      deliveries where this drifts too far from your clock to mitigate replay. |

      | `X-Outpost-Signature` | `v0=<hex>` HMAC-SHA256 of the raw request body,
      keyed with your endpoint's signing secret. |


      ### Verifying the signature


      The signature is computed over the **raw request body**:


      ```

      HMAC-SHA256(signing_secret, raw_body)

      ```


      Encoded as hex, prefixed with `v0=`. **Use a constant-time comparison** to
      avoid timing attacks.


      `rawBody` is the unparsed request body — the exact `Buffer` or string you
      received over the wire, not a re-serialised JSON object.


      ```js

      import { createHmac, timingSafeEqual } from 'node:crypto';


      function verify(rawBody, signatureHeader, secret) {
        if (!signatureHeader) return false;
        const expected =
          'v0=' + createHmac('sha256', secret).update(rawBody).digest('hex');
        // Header may carry multiple comma-separated signatures during a rotation window.
        return signatureHeader.split(',').some((sig) => {
          const got = Buffer.from(sig.trim());
          const want = Buffer.from(expected);
          return got.length === want.length && timingSafeEqual(got, want);
        });
      }

      ```


      ### Secret rotation


      Rotating a signing secret keeps the previous secret valid for 24 hours so
      you can roll the new one out without dropped deliveries. During that
      window, the `X-Outpost-Signature` header carries comma-separated
      signatures (`v0=<new>,v0=<previous>`); accept either.


      The new secret is shown **once** at rotation and is never retrievable
      later.
    name: Webhooks
externalDocs:
  description: OpenAPI JSON Specification
  url: /v1/public/swagger/doc.json
paths:
  /transactions:
    get:
      tags:
        - Financial
      summary: List card transactions
      description: >-
        Retrieves a paginated list of card transactions for the authenticated
        account. Each entry's `id` matches the `transactionId` field emitted on
        card financial event webhooks, so webhook deliveries and API rows can be
        reconciled directly. Returned in reverse chronological order by
        `createdAt`.


        If both pagination parameters are not provided, a default of page 1 with
        size 100 is used. Max page size is 100. For post-settlement
        reconciliation against payment cycles, see `/settlements`.
      parameters:
        - description: Inclusive lower bound on `createdAt`, format YYYY-MM-DD
          in: query
          name: from
          schema:
            type: string
        - description: Inclusive upper bound on `createdAt`, format YYYY-MM-DD
          in: query
          name: to
          schema:
            type: string
        - description: Page number
          in: query
          name: page
          schema:
            minimum: 1
            type: integer
        - description: Number of items per page
          in: query
          name: pageSize
          schema:
            maximum: 100
            minimum: 1
            type: integer
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/pagination.Page-Transaction'
          description: Paginated list of card transactions
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidationErrorResponse'
          description: Validation error
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/UnauthorizedErrorResponse'
          description: Unauthorized
        '500':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InternalServerErrorResponse'
          description: Internal server error
      security:
        - BearerAuth: []
components:
  schemas:
    pagination.Page-Transaction:
      properties:
        data:
          description: Array of items on the current page.
          items:
            $ref: '#/components/schemas/Transaction'
          type: array
          uniqueItems: false
        page:
          description: Current page.
          example: 10
          type: integer
        pageSize:
          description: Number of items per page.
          example: 1
          type: integer
        totalItemCount:
          description: Total number of items.
          example: 50
          minimum: 0
          type: integer
        totalPages:
          description: Total number of pages.
          example: 5
          minimum: 1
          type: integer
      required:
        - data
      type: object
    ValidationErrorResponse:
      properties:
        code:
          type: string
        message:
          type: string
      required:
        - code
      type: object
    UnauthorizedErrorResponse:
      properties:
        code:
          example: unauthorized
          type: string
        message:
          example: authorization header not provided
          type: string
      required:
        - code
      type: object
    InternalServerErrorResponse:
      properties:
        code:
          example: internal-server-error
          type: string
        message:
          type: string
      required:
        - code
      type: object
    Transaction:
      properties:
        amount:
          description: >-
            Transaction amount. Reflects the pending authorization amount while
            the transaction is pending or declined, and the settled amount once
            settled. Zero for released authorizations.
          example: '25.78'
          format: decimal multiple of 0.01
          type: string
        amountDirection:
          $ref: '#/components/schemas/iso.AmountDirection'
        cardId:
          description: Card the transaction was placed on.
          example: 123e4567-e89b-12d3-a456-426614174002
          format: uuid
          type: string
        createdAt:
          description: >-
            External network creation time — the field the list is sorted and
            date-filtered by, and the same value the card financial event
            webhook emits as `createdAt`.
          example: '2025-01-11T22:10:43.979Z'
          format: YYYY-MM-DDTHH:MM:SS.MSZ
          type: string
        currency:
          description: ISO 4217 currency code of the amount.
          example: USD
          type: string
        id:
          description: >-
            Unique identifier. Matches the `transactionId` field on card
            financial event webhooks, allowing reconciliation between this
            endpoint and webhook deliveries.
          example: 123e4567-e89b-12d3-a456-426614174005
          format: uuid
          type: string
        merchantName:
          description: >-
            Merchant name as reported by the card network. Omitted when the
            network did not supply one.
          example: FACEBK *RN4NULM232
          type: string
        status:
          $ref: '#/components/schemas/domaintype.TransactionStatus'
      required:
        - amount
        - amountDirection
        - cardId
        - createdAt
        - currency
        - id
        - status
      type: object
    iso.AmountDirection:
      description: >-
        Amount direction. `debit` reduces the card balance, `credit` is a
        refund.
      enum:
        - debit
        - credit
      example: debit
      type: string
      x-enum-varnames:
        - DebitAmount
        - CreditAmount
    domaintype.TransactionStatus:
      description: Lifecycle stage of the transaction.
      enum:
        - pending
        - declined
        - settled
        - released
        - pending
        - declined
        - settled
        - released
      example: settled
      type: string
      x-enum-varnames:
        - PendingTransaction
        - DeclinedTransaction
        - SettledTransaction
        - ReleasedTransaction
  securitySchemes:
    BearerAuth:
      description: >-
        Type "Bearer" followed by a space and your API token. Obtain your key
        from the Dash.fi dashboard. Example: "Bearer YOUR_API_KEY"
      in: header
      name: Authorization
      type: apiKey

````