> This page is for version 2025-09-18 (default).
> For other versions, use one of these documentation indexes:
> - 2025-09-18 (default): https://apidocs.polytomic.com/2025-09-18/llms.txt
> - 2024-02-08: https://apidocs.polytomic.com/2024-02-08/llms.txt
> - 2023-04-25: https://apidocs.polytomic.com/2023-04-25/llms.txt
> - 2022-12-12: https://apidocs.polytomic.com/2022-12-12/llms.txt
> - 2021-05-23: https://apidocs.polytomic.com/2021-05-23/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://apidocs.polytomic.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://apidocs.polytomic.com/_mcp/server.

# List Syncs

GET https://app.polytomic.com/api/syncs

Lists model syncs in the caller's organization.

Results are ordered by `updated_at` descending, with `id` used as a tiebreaker.
If more results are available, the response includes `pagination.next_page_token`.
Pass that token back unchanged to continue from the last item you received.

The token is opaque. Do not construct or edit it yourself.

The `limit` is capped at 50. Values above that cap are reduced to 50, and
non-positive values fall back to the same default.

This endpoint returns syncs visible to the current caller's organization scope.
To inspect a specific sync in more detail, follow up with
[`GET /api/syncs/{id}`](../../api-reference/model-sync/get).

Reference: https://apidocs.polytomic.com/api-reference/model-sync/list

## Authentication

- `Authorization` header (bearer token, required) — Bearer user API key
- `Authorization` header (basic auth, required) — Basic organization-scoped API key

## Request

### Query parameters

- `active` (boolean, optional) — Filter to only active or only paused syncs.
- `mode` (enum, optional) — Filter by sync target mode (e.g. create, updateOrCreate, enrich).
  - Allowed values: `create`, `update`, `updateOrCreate`, `replace`, `append`, `remove`, `snapshot`
- `target_connection_id` (string, optional) — Filter to syncs that write to the specified target connection.
- `page_token` (string, optional) — Pagination cursor returned in the previous response. Omit on the first request.
- `limit` (integer, optional) — Maximum number of syncs to return. Default and maximum is 50.

## Response

### 200

OK

- `data` (list of ListSyncItem, optional, nullable)
- `pagination` (PaginationDetails, optional)

## Errors

### 400 Bad Request Error

Bad Request

- `key` (string, optional)
- `message` (string, optional)
- `metadata` (map from string to any, optional)
- `status` (integer, optional)

### 404 Not Found Error

Not Found

- `key` (string, optional)
- `message` (string, optional)
- `metadata` (map from string to any, optional)
- `status` (integer, optional)

### 500 Internal Server Error

Internal Server Error

- `key` (string, optional)
- `message` (string, optional)
- `metadata` (map from string to any, optional)
- `status` (integer, optional)

## Types

### ListSyncItem

- `active` (boolean, optional) — Whether the sync runs on its schedule.
- `created_at` (datetime, optional) — Timestamp the sync was created.
- `created_by` (OutputActor, optional)
- `id` (string, optional) — Unique identifier of the sync.
- `mode` (string, optional) — How source records are written to the target (e.g. create, updateOrCreate, enrich).
- `model_ids` (list of string, optional) — Model IDs used in the sync.
- `name` (string, optional) — Human-readable name of the sync.
- `only_enrich_updates` (boolean, optional) — For enrichment syncs, only process records that have been updated since the previous run.
- `organization_id` (string, optional) — Organization the sync belongs to.
- `schedule` (Schedule, optional)
- `skip_initial_backfill` (boolean, optional) — When true, the first execution of the sync skips the initial backfill and only processes new changes.
- `sync_all_records` (boolean, optional) — When true, every execution syncs the full set of source records rather than only changes since the previous run.
- `target_connection_id` (string, optional) — Connection the sync writes to.
- `target_object` (string, optional) — Destination object (e.g. table, SaaS object) the sync writes to.
- `updated_at` (datetime, optional) — Timestamp the sync was last updated.
- `updated_by` (OutputActor, optional)

### PaginationDetails

- `next_page_token` (string, optional)

### OutputActor

- `id` (string, optional)
- `name` (string, optional)
- `type` (string, optional)

### Schedule

- `connection_id` (string, optional)
- `day_of_month` (string, optional, nullable)
- `day_of_week` (string, optional, nullable)
- `frequency` (enum, optional)
  - Allowed values: `manual`, `continuous`, `hourly`, `daily`, `weekly`, `custom`, `builder`, `runafter`, `multi`, `dbtcloud`
- `hour` (string, optional, nullable)
- `job_id` (integer, optional, nullable)
- `minute` (string, optional, nullable)
- `month` (string, optional, nullable)
- `run_after` (RunAfter, optional)
- `run_after_success_only` (boolean, optional, nullable) — If true, the sync will only run if the dependent syncs completed successfully.

### RunAfter

- `bulk_sync_ids` (list of string, optional)
- `sync_ids` (list of string, optional)

## Examples

**Response**

```json
{
  "data": [
    {
      "active": true,
      "created_at": "2024-01-15T09:30:00Z",
      "created_by": {
        "id": "12345678-1234-1234-1234-123456789012",
        "name": "John Doe",
        "type": "user"
      },
      "id": "248df4b7-aa70-47b8-a036-33ac447e668d",
      "mode": "create",
      "model_ids": [
        "12345678-1234-1234-1234-123456789012",
        "98765432-1234-1234-1234-123456789012"
      ],
      "name": "Users Sync",
      "only_enrich_updates": false,
      "organization_id": "248df4b7-aa70-47b8-a036-33ac447e668d",
      "schedule": {
        "connection_id": "248df4b7-aa70-47b8-a036-33ac447e668d",
        "day_of_month": "1",
        "day_of_week": "monday",
        "frequency": "manual",
        "hour": "12",
        "job_id": 1,
        "minute": "30",
        "month": "1",
        "run_after": {
          "bulk_sync_ids": [
            "248df4b7-aa70-47b8-a036-33ac447e668d"
          ],
          "sync_ids": [
            "248df4b7-aa70-47b8-a036-33ac447e668d"
          ]
        },
        "run_after_success_only": true
      },
      "skip_initial_backfill": false,
      "sync_all_records": false,
      "target_connection_id": "248df4b7-aa70-47b8-a036-33ac447e668d",
      "target_object": "Users",
      "updated_at": "2024-01-15T09:30:00Z",
      "updated_by": {
        "id": "12345678-1234-1234-1234-123456789012",
        "name": "John Doe",
        "type": "user"
      }
    }
  ],
  "pagination": {
    "next_page_token": "AmkYh8v0jR5B3kls2Qcc9y8MjrPmvR4CvaK7H0F4rEwqvg76K=="
  }
}
```

**SDK Code**

```python
import requests

url = "https://app.polytomic.com/api/syncs"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://app.polytomic.com/api/syncs';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://app.polytomic.com/api/syncs"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://app.polytomic.com/api/syncs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://app.polytomic.com/api/syncs")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://app.polytomic.com/api/syncs', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://app.polytomic.com/api/syncs");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://app.polytomic.com/api/syncs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```