Use delta sync to detect changed tables efficiently

Discover which tables have been updated since your last sync without fetching every endpoint. The Data API GET /v1/changes endpoint returns metadata for changed tables and supports conditional requests via ETag to skip polling when nothing is new.

Poll /v1/changes every 15–60 minutes. The underlying sync runs as a daily batch, so polling more often will not surface newer data — it only spends more of your 2,500 req/h budget, which all endpoints share. Combine this with the since/ETag pattern below so unchanged polls stay cheap.

With a transformed key, /v1/changes lists only tables within the key’s categories and tables; tables without a category are never listed, and ?category=X outside the key’s scope returns 403. A raw key sees all tables — see Key types.

Poll for changed tables

Send a GET request to /v1/changes with an ISO-8601 since timestamp (UTC, e.g. …Z). An offset such as +02:00 is converted to UTC; in a query string write the + as %2B, otherwise it is read as a space and the request fails with 400. The response lists every table whose last_sync_at is after that timestamp, including the corresponding endpoint URL. A table listed here has to be fetched in full again — /v1/changes reports changed tables, not changed rows. endpoint_url points to the path to fetch: /v1/{category}/{table} for category tables, /v1/raw/{table} for raw tables. Raw tables that are blocked for your account are not listed. Add an optional category parameter (e.g. category=property) to only return tables belonging to that category.

curl -s "https://api.trassets.ai/v1/changes?since=2026-07-01T00:00:00Z" \
  -H "X-API-Key: $TRASSETS_API_KEY"

Example response:

[
  {
    "table_name": "properties",
    "last_sync_at": "2026-07-07T06:00:00",
    "category": "property",
    "api_table_name": "properties",
    "endpoint_url": "/v1/property/properties"
  },
  {
    "table_name": "sollart",
    "last_sync_at": "2026-07-07T06:05:00",
    "category": null,
    "api_table_name": null,
    "endpoint_url": "/v1/raw/sollart"
  }
]

Fetch only changed tables

For each item returned by /v1/changes, request the corresponding endpoint only. Skip any table that is absent from the response. This avoids unnecessary data transfer and preserves your 2,500 req/h rate limit budget.

Use conditional GET on subsequent polls

Store the ETag header from the first successful /v1/changes response. On your next poll, send it back as If-None-Match.

curl -s "https://api.trassets.ai/v1/changes?since=2026-07-01T00:00:00Z" \
  -H "X-API-Key: $TRASSETS_API_KEY" \
  -H "If-None-Match: \"abc123\""

The ETag depends on since and category as well, so keep the ETag together with the since it was issued for. If no tables have changed since the ETag was issued, the API returns 304 Not Modified with an empty body and skips the database query. The request still counts toward your rate limit.

Advance the since parameter

After a successful sync, store the highest last_sync_at from the /v1/changes response and use it as the since value for the next poll. This creates a sliding window so each run evaluates only the interval since the previous run. If the response is empty, keep the old since.Do not use your own clock here. Client and server clocks drift, and a table that finished syncing shortly before your timestamp would never appear in a later /v1/changes response.

Full Python example

A complete poller that tracks the since timestamp and ETag between runs, and only processes tables that actually changed. Requires the requests package.

poll_changes.py

import os

import requests

API_KEY = os.environ["TRASSETS_API_KEY"]
BASE_URL = "https://api.trassets.ai"
HEADERS = {"X-API-Key": API_KEY}


def poll_changes(since: str, etag: str | None = None):
    """Poll /v1/changes and return (changed_tables, new_etag, new_since).

    changed_tables is an empty list on a 304 Not Modified response, and
    new_since stays unchanged then.
    """
    headers = dict(HEADERS)
    if etag:
        headers["If-None-Match"] = etag

    resp = requests.get(
        f"{BASE_URL}/v1/changes", headers=headers, params={"since": since}, timeout=30
    )

    if resp.status_code == 304:
        return [], etag, since

    resp.raise_for_status()
    changed = resp.json()
    if not changed:
        return [], resp.headers.get("ETag"), since
    # last_sync_at is UTC without a suffix; the API expects it with "Z"
    new_since = max(t["last_sync_at"] for t in changed) + "Z"
    return changed, resp.headers.get("ETag"), new_since


if __name__ == "__main__":
    since = "2026-07-01T00:00:00Z"
    etag = None

    changed, etag, since = poll_changes(since, etag)
    for table in changed:
        print(f"Changed: {table['table_name']} -> {table['endpoint_url']}")
    if not changed:
        print("No changes since last poll.")

    # Persist `since` and `etag` and pass them into the next scheduled run.

The since parameter must not be older than 120 days. Requests with a timestamp beyond this lookback window return an error. Run a full table refresh if your last successful sync was more than 120 days ago.

Get Started

Core Concepts

Guides

Data Model

Use delta sync to detect changed tables efficiently