From a key to synced data in five minutes

export REVO_KEY=rvo_live_…   # from REVO → Setări → Chei API
curl https://api.revoapp.ro/api/public/v1/me \
  -H "Authorization: Bearer $REVO_KEY" \
  -H "Accept: application/json"

// Node 18+ (fetch is built in). Keep the key on the server.
const API = 'https://api.revoapp.ro/api/public/v1';
const headers = { Authorization: `Bearer ${process.env.REVO_KEY}`, Accept: 'application/json' };

async function revo(path, params = {}) {
  const query = new URLSearchParams(params).toString();
  const res = await fetch(`${API}${path}${query ? `?${query}` : ''}`, { headers });
  const body = await res.json();
  if (!res.ok) throw new Error(`${res.status} ${body.error.code}: ${body.error.message}`);
  return body;
}

const me = await revo('/me');
console.log(me.business.name, me.scopes, me.all_locations ? 'all locations' : me.location_ids);

<?php
const REVO_API = 'https://api.revoapp.ro/api/public/v1';

function revo(string $path, array $params = []): array
{
    $url = REVO_API.$path.($params ? '?'.http_build_query($params) : '');
    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HTTPHEADER => ['Authorization: Bearer '.getenv('REVO_KEY'), 'Accept: application/json'],
    ]);
    $body = json_decode((string) curl_exec($ch), true);
    $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    curl_close($ch);
    if ($status >= 400) {
        throw new RuntimeException("$status {$body['error']['code']}: {$body['error']['message']}");
    }

    return $body;
}

$me = revo('/me');
echo $me['business']['name'].' — '.implode(', ', $me['scopes']).PHP_EOL;

import os
import requests

API = "https://api.revoapp.ro/api/public/v1"
session = requests.Session()
session.headers.update({"Authorization": f"Bearer {os.environ['REVO_KEY']}", "Accept": "application/json"})

def revo(path, **params):
    res = session.get(f"{API}{path}", params=params, timeout=30)
    body = res.json()
    if res.status_code >= 400:
        raise RuntimeError(f"{res.status_code} {body['error']['code']}: {body['error']['message']}")
    return body

me = revo("/me")
print(me["business"]["name"], me["scopes"])

curl "https://api.revoapp.ro/api/public/v1/products?limit=200" \
  -H "Authorization: Bearer $REVO_KEY"
# Next page: the same URL plus &cursor=<next_cursor of the previous answer>

async function listAll(path, params = {}) {
  const rows = [];
  let cursor = null;
  do {
    const page = await revo(path, { ...params, limit: '200', ...(cursor ? { cursor } : {}) });
    rows.push(...page.data);
    cursor = page.has_more ? page.next_cursor : null;
  } while (cursor);
  return rows;
}

const products = await listAll('/products');
for (const p of products) {
  console.log(p.name, p.price, p.unit === 'kg' ? 'per kg' : '', p.available ? '' : '(sold out)');
}

function revo_list(string $path, array $params = []): array
{
    $rows = [];
    $cursor = null;
    do {
        $page = revo($path, $params + ['limit' => 200] + ($cursor ? ['cursor' => $cursor] : []));
        array_push($rows, ...$page['data']);
        $cursor = $page['has_more'] ? $page['next_cursor'] : null;
    } while ($cursor !== null);

    return $rows;
}

foreach (revo_list('/products') as $p) {
    echo $p['name'].' '.$p['price'].($p['available'] ? '' : ' (sold out)').PHP_EOL;
}

def list_all(path, **params):
    rows, cursor = [], None
    while True:
        page = revo(path, **params, limit=200, **({"cursor": cursor} if cursor else {}))
        rows += page["data"]
        if not page["has_more"]:
            return rows
        cursor = page["next_cursor"]

for p in list_all("/products"):
    print(p["name"], p["price"], "" if p["available"] else "(sold out)")

curl "https://api.revoapp.ro/api/public/v1/products?updated_since=2026-10-05T12:00:00Z&limit=200" \
  -H "Authorization: Bearer $REVO_KEY"

// `store` is your database: upsert(row), remove(id), and a saved mark per list.
async function syncProducts(store) {
  const since = await store.getMark('products'); // null the first time
  const rows = await listAll('/products', since ? { updated_since: since } : {});
  let newest = since;
  for (const row of rows) {
    if (row.deleted) await store.remove(row.id);
    else await store.upsert(row);
    if (!newest || row.updated_at > newest) newest = row.updated_at;
  }
  if (newest) {
    // Start the next sync two minutes earlier: changes still being saved are caught.
    await store.setMark('products', new Date(Date.parse(newest) - 120_000).toISOString());
  }
}

function revo_sync_products(PDO $db, ?string $since): ?string
{
    $rows = revo_list('/products', $since ? ['updated_since' => $since] : []);
    $newest = $since;
    foreach ($rows as $row) {
        if ($row['deleted']) {
            $db->prepare('DELETE FROM revo_products WHERE id = ?')->execute([$row['id']]);
        } else {
            $db->prepare('REPLACE INTO revo_products (id, json) VALUES (?, ?)')->execute([$row['id'], json_encode($row)]);
        }
        $newest = max($newest ?? '', $row['updated_at']);
    }
    // The next mark: two minutes before the newest change.
    return $newest ? gmdate('Y-m-d\TH:i:s\Z', strtotime($newest) - 120) : null;
}

from datetime import datetime, timedelta

def sync_products(store, since=None):
    rows = list_all("/products", **({"updated_since": since} if since else {}))
    newest = since
    for row in rows:
        if row["deleted"]:
            store.remove(row["id"])
        else:
            store.upsert(row)
        newest = max(newest or "", row["updated_at"])
    if not newest:
        return None
    # The next mark: two minutes before the newest change.
    mark = datetime.fromisoformat(newest.replace("Z", "+00:00")) - timedelta(minutes=2)
    return mark.strftime("%Y-%m-%dT%H:%M:%SZ")

curl "https://api.revoapp.ro/api/public/v1/sales/daily?from=2026-10-01&to=2026-10-07" \
  -H "Authorization: Bearer $REVO_KEY"

const week = await revo('/sales/daily', { from: '2026-10-01', to: '2026-10-07' });
for (const day of week.data) console.log(day.date, day.orders, day.net_sales);
console.log('Total', week.totals.net_sales, week.currency);

$week = revo('/sales/daily', ['from' => '2026-10-01', 'to' => '2026-10-07']);
foreach ($week['data'] as $day) {
    printf("%s  %3d orders  %s RON\n", $day['date'], $day['orders'], $day['net_sales']);
}
echo 'Total '.$week['totals']['net_sales'].' RON'.PHP_EOL;

week = revo("/sales/daily", **{"from": "2026-10-01", "to": "2026-10-07"})
for day in week["data"]:
    print(day["date"], day["orders"], day["net_sales"])
print("Total", week["totals"]["net_sales"], week["currency"])

curl "https://api.revoapp.ro/api/public/v1/ingredients?below_min=true" \
  -H "Authorization: Bearer $REVO_KEY"

const low = await listAll('/ingredients', { below_min: 'true' });
for (const i of low) console.log(`${i.name}: ${i.stock} ${i.unit} (minimum ${i.min_stock})`);

foreach (revo_list('/ingredients', ['below_min' => 'true']) as $i) {
    echo "{$i['name']}: {$i['stock']} {$i['unit']} (minimum {$i['min_stock']})".PHP_EOL;
}

for i in list_all("/ingredients", below_min="true"):
    print(f"{i['name']}: {i['stock']} {i['unit']} (minimum {i['min_stock']})")

async function withRetry(call, tries = 5) {
  for (let attempt = 0; ; attempt++) {
    try {
      return await call();
    } catch (err) {
      const status = Number(String(err.message).slice(0, 3));
      if (attempt >= tries - 1 || ![429, 500, 503].includes(status)) throw err;
      await new Promise((r) => setTimeout(r, Math.min(60_000, 1000 * 2 ** attempt)));
    }
  }
}

const today = await withRetry(() => revo('/sales/daily'));

function revo_retry(callable $call, int $tries = 5)
{
    for ($attempt = 0; ; $attempt++) {
        try {
            return $call();
        } catch (RuntimeException $e) {
            $status = (int) substr($e->getMessage(), 0, 3);
            if ($attempt >= $tries - 1 || ! in_array($status, [429, 500, 503], true)) {
                throw $e;
            }
            sleep(min(60, 2 ** $attempt));
        }
    }
}

$today = revo_retry(fn () => revo('/sales/daily'));

import time

def with_retry(call, tries=5):
    for attempt in range(tries):
        try:
            return call()
        except RuntimeError as err:
            status = int(str(err)[:3])
            if attempt == tries - 1 or status not in (429, 500, 503):
                raise
            time.sleep(min(60, 2 ** attempt))

today = with_retry(lambda: revo("/sales/daily"))

import crypto from 'node:crypto';

export function verifyRevo(rawBody, header, secret) {
  const parts = Object.fromEntries(header.split(',').map((p) => p.split('=')));
  const expected = crypto.createHmac('sha256', secret).update(`${parts.t}.${rawBody}`).digest('hex');
  const fresh = Math.abs(Date.now() / 1000 - Number(parts.t)) <= 300;
  return fresh && expected.length === parts.v1?.length &&
    crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(parts.v1));
}

function verify_revo(string $rawBody, string $header, string $secret): bool
{
    parse_str(str_replace(',', '&', $header), $p);
    $expected = hash_hmac('sha256', ($p['t'] ?? '').'.'.$rawBody, $secret);

    return abs(time() - (int) ($p['t'] ?? 0)) <= 300 && hash_equals($expected, $p['v1'] ?? '');
}

import hashlib, hmac, time

def verify_revo(raw_body: bytes, header: str, secret: str) -> bool:
    parts = dict(p.split("=", 1) for p in header.split(","))
    expected = hmac.new(secret.encode(), f"{parts.get('t', '')}.".encode() + raw_body, hashlib.sha256).hexdigest()
    fresh = abs(time.time() - int(parts.get("t", 0))) <= 300
    return fresh and hmac.compare_digest(expected, parts.get("v1", ""))