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

# Pull Synced Records

> Get records from a Sync

Each page that you consume when pulling synced records returns a stable cursor for the last record of that page in `paging.cursor`.

When you receive data as an empty array or `paging.remainingRecords` = 0, your application is caught up to the latest data synced to Paragon.

You can persist the last available `paging.cursor` value and resume from it later — for example, when you receive `record_created` or `record_updated` webhooks, or when polling for new changes using a recurring job.

<Accordion title="Pagination and cursor behavior">
  Records from this endpoint are ordered as a change log of creates, updates, and deletes, based on when Paragon last synced each record.

  You can always pass a `cursor` value that you received from the API as `paging.cursor` to catch up on all creates, updates, and deletes that Paragon observed since that page.

  **What if data changes while I am ingesting records from the Initial Sync?**

  If records are created or updated while you are still paging through a large Sync (for example during an initial pull of many files), those changes can appear on later pages of the same pull loop. That includes updates to records you already consumed earlier in the loop, so you can pick up the latest content even when source data changes mid-pull.

  **Can I use a pagination cursor after full or incremental syncs run?**

  Yes, any cursor provided by the API remains valid for resuming from that point at any time later, including after a periodic full sync has run.

  The `latestCursor` returned from the API can change after a full or incremental sync because new or updated records may be available to pull when a sync detects changes. However, you can still pass your saved cursor to continue from where you left off.
</Accordion>


## OpenAPI

````yaml get /api/syncs/{syncId}/records
openapi: 3.0.0
info:
  title: Paragon Sync API
  description: API for managing Syncs and permissions for Connected Users
  version: 1.0.0
servers:
  - url: https://sync.useparagon.com
    description: Production server
security:
  - bearerAuth: []
paths:
  /api/syncs/{syncId}/records:
    get:
      summary: Pull Synced Records
      description: Get records from a Sync
      parameters:
        - name: syncId
          in: path
          required: true
          schema:
            type: string
          description: ID of the sync
        - name: pageSize
          in: query
          required: false
          schema:
            type: integer
          description: Number of records to return per page
          example: 100
        - name: cursor
          in: query
          required: false
          schema:
            type: string
          description: >-
            Pagination cursor returned in `paging.cursor` from a previous
            response. Pass it to resume from that point in the change log of
            synced records.
          example: Y3Vyc29yOjEyMQ==
      responses:
        '200':
          description: Synced records
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SyncedRecordsResponse'
        '401':
          description: Unauthorized
        '404':
          description: Sync not found
components:
  schemas:
    SyncedRecordsResponse:
      type: object
      required:
        - data
        - paging
      properties:
        data:
          type: array
          items:
            type: object
          description: >-
            Array of synced records. See schemas in [**Synced
            Objects**](https://docs.useparagon.com/managed-sync/synced-objects)
            for the available fields.
          example: '[/* See schema in Synced Objects */]'
        paging:
          type: object
          required:
            - totalRecords
            - totalActiveRecords
            - remainingRecords
            - cursor
            - lastSeen
          properties:
            totalRecords:
              type: integer
              description: Total number of records in this Sync
            totalActiveRecords:
              type: integer
              description: Total number of non-deleted records tracked by this Sync
            remainingRecords:
              type: integer
              description: >-
                Number of records remaining to be synced after the current
                cursor
            cursor:
              type: string
              description: >-
                Pagination cursor for the last record on this page. Pass it as
                the `cursor` query parameter to fetch subsequent records.
                Remains valid for resume after full or incremental syncs.
            lastSeen:
              type: integer
              description: >-
                UNIX timestamp (in milliseconds) of when the last record was
                synced
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: Paragon User Token. Add to the Authorization header of your requests.

````