Zime API Reference

curl -G 'https://embedding-api-prod.zime.ai/api/v1/calls' \
  -H 'X-API-Key: YOUR_API_KEY' \
  --data-urlencode 'start-date=2026-06-01' \
  --data-urlencode 'end-date=2026-06-30'

{
  "data": [ ... ],
  "pagination": {
    "has_more": true,
    "next_cursor": 12245,
    "page_size": 100,
    "returned_count": 100
  }
}

#!/usr/bin/env python3
"""Export Zime API data over a date range. Python 3.8+, standard library only.

Two loops: an outer loop over date chunks, an inner cursor-pagination loop
within each chunk. Chunks overlap by two days because a call that starts
before a chunk boundary and ends after it belongs to neither side; duplicates
from the overlap are removed automatically.

  export ZIME_API_KEY=your_key
  python3 zime_export.py --endpoint insight \
      --start-date 2026-01-01 --end-date 2026-08-31 --out insights.ndjson

Re-run the same command to resume an interrupted export.
"""
import argparse, json, os, sys, time, urllib.error, urllib.parse, urllib.request
from datetime import datetime, timedelta

BASE_URL = 'https://embedding-api-prod.zime.ai'
FMT = '%Y-%m-%d'
ENDPOINTS = {
    'calls':      {'path': '/api/v1/calls',            'max_page': 1000, 'key': ('call_id',)},
    'insight':    {'path': '/api/v1/calls/insight',    'max_page': 100,  'key': ('call_id', 'insight_id')},
    'transcript': {'path': '/api/v1/calls/transcript', 'max_page': 100,  'key': ('call_id',)},
}


def log(m):
    print('%s  %s' % (datetime.now().strftime('%H:%M:%S'), m), file=sys.stderr, flush=True)


def chunks(start, end, days, overlap):
    cur, final = datetime.strptime(start, FMT), datetime.strptime(end, FMT)
    while cur <= final:
        nominal = min(cur + timedelta(days=days - 1), final)
        yield cur.strftime(FMT), min(nominal + timedelta(days=overlap), final).strftime(FMT)
        cur = nominal + timedelta(days=1)


def fetch(url, key, timeout, retries=5):
    for attempt in range(retries + 1):
        try:
            req = urllib.request.Request(url, headers={'X-API-Key': key})
            with urllib.request.urlopen(req, timeout=timeout) as r:
                return json.loads(r.read().decode())
        except urllib.error.HTTPError as e:
            if e.code != 429 and e.code < 500:
                raise SystemExit('HTTP %d: %s' % (e.code, e.read().decode('utf-8', 'replace')[:300]))
            reason = 'HTTP %d' % e.code
        except Exception as e:
            reason = type(e).__name__
        if attempt == retries:
            raise SystemExit('giving up after %d retries (%s)' % (retries, reason))
        wait = min(60, 2 ** (attempt + 1))
        log('  %s - retrying in %ds' % (reason, wait))
        time.sleep(wait)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('--endpoint', required=True, choices=sorted(ENDPOINTS))
    ap.add_argument('--api-key', default=os.environ.get('ZIME_API_KEY'))
    ap.add_argument('--start-date', required=True)
    ap.add_argument('--end-date', required=True)
    ap.add_argument('--out', required=True)
    ap.add_argument('--chunk-days', type=int, default=30)
    ap.add_argument('--overlap-days', type=int, default=2)
    ap.add_argument('--page-size', type=int, default=None)
    ap.add_argument('--delay', type=float, default=1.0)
    ap.add_argument('--timeout', type=int, default=300)
    a = ap.parse_args()

    if not a.api_key:
        raise SystemExit('set ZIME_API_KEY or pass --api-key')
    spec = ENDPOINTS[a.endpoint]
    page_size = min(a.page_size or spec['max_page'], spec['max_page'])

    ck = a.out + '.checkpoint'
    state = (json.load(open(ck)) if os.path.exists(ck)
             else {'done': [], 'seen': [], 'n': 0, 'dropped': 0, 'offset': 0})
    done = set(map(tuple, state['done']))
    seen = set(map(tuple, state['seen']))
    dropped = state['dropped']

    todo = list(chunks(a.start_date, a.end_date, a.chunk_days, a.overlap_days))
    log('%s: %d chunk(s) of %dd (+%dd overlap), page-size %d'
        % (a.endpoint, len(todo), a.chunk_days, a.overlap_days, page_size))

    # Truncate back to the last completed chunk. A chunk interrupted mid-run has
    # already flushed rows to disk that the checkpoint never recorded; without this
    # they would be written a second time on resume.
    if done and os.path.exists(a.out):
        with open(a.out, 'r+') as f:
            f.truncate(state['offset'])

    with open(a.out, 'a' if done else 'w') as out:
        for i, (cs, ce) in enumerate(todo, 1):
            if (cs, ce) in done:
                continue
            cursor, written = None, 0
            while True:
                q = {'start-date': cs, 'end-date': ce, 'page-size': str(page_size)}
                if cursor is not None:
                    q['after-key'] = str(cursor)
                d = fetch(BASE_URL + spec['path'] + '?' + urllib.parse.urlencode(q), a.api_key, a.timeout)
                for row in d.get('data') or []:
                    rk = tuple(row.get(f) for f in spec['key'])
                    if rk in seen:
                        dropped += 1
                        continue
                    seen.add(rk)
                    out.write(json.dumps(row, separators=(',', ':')) + '\n')
                    written += 1
                out.flush()
                page = d.get('pagination') or {}
                cursor = page.get('next_cursor')
                if not page.get('has_more') or cursor is None:
                    break
                time.sleep(a.delay)
            state.update(n=state['n'] + written, dropped=dropped, offset=out.tell(),
                         seen=[list(k) for k in seen], done=state['done'] + [[cs, ce]])
            done.add((cs, ce))
            json.dump(state, open(ck, 'w'))
            log('[%d/%d] %s..%s  +%d  (total %d)' % (i, len(todo), cs, ce, written, state['n']))
            time.sleep(a.delay)

    log('done: %d record(s) -> %s' % (state['n'], a.out))
    if dropped:
        log('removed %d duplicate row(s)' % dropped)
    os.remove(ck)


if __name__ == '__main__':
    main()

export ZIME_API_KEY=your_api_key

# a full year of insights
python3 zime_export.py --endpoint insight \
  --start-date 2026-01-01 --end-date 2026-12-31 \
  --out insights.ndjson

# transcripts from a memory-constrained runtime
python3 zime_export.py --endpoint transcript \
  --start-date 2026-01-01 --end-date 2026-12-31 \
  --page-size 25 --out transcripts.ndjson

{ "error": "start-date parameter is required (format: YYYY-MM-DD)" }