Delta sync & bulk operations

Delta sync — records changed since a timestamp

records supports incremental sync directly on list: pass updated_since (a Unix timestamp) and the paginator streams only the records changed at or after that moment, so you don't re-pull the whole dataset. Pair it with list_deleted to also learn which records were removed since the same point.

since = "1704067200"                                 # Unix timestamp of your last sync
for record in bs.records.list(updated_since=since):  # streams changed records
    reindex(record)
for deleted_id in bs.records.list_deleted(updated_since=since):
    drop(deleted_id)

for await (const r of bs.records.list({ updatedSince: 1704067200 })) { reindex(r); }
for await (const id of bs.records.listDeleted({ updatedSince: 1704067200 })) { drop(id); }

> list_deleted returns just the deleted record IDs (not full models), so a sync > can prune its local copy without a second lookup.

Bulk with chunking

Bulk is not a separate method — the verb is polymorphic and the argument shape decides: delete(42) deletes one record, delete([1, 2]) deletes many in one request; update(42, data) vs update([rec1, rec2]) likewise. (Go has no overloads, so the list shape is DeleteMany / UpdateMany there.)

For large inputs the *Chunked variant splits the array into chunks and reports per-chunk outcomes instead of failing all-or-nothing:

result = bs.records.update_chunked(batch, chunk_size=100)
print(result.succeeded, result.failed)   # BulkResult: successes + per-chunk errors
for err in result.errors:
    print(err.chunk_index, err.error)

const result = await bs.records.updateChunked(batch, 100);

result, _ := bs.Records.UpdateManyChunked(ctx, batch, 100)

A plain bulk update([records]) is a single request (all-or-nothing); updateChunked trades atomicity for resilience + progress on big batches. Each chunk is one API call — see the method's Cost: line.