דוגמה — סנכרון יוצא עם עימוד

עודכן 30.08.2026

GET /parse/classes/TABLE?where=…&keys=…&order=createdAt&limit=1000

“תמשכו לנו את כל הלקוחות למחסן הנתונים” נשמעת כמו משימה של חצי שעה, והיא באמת כזו — עד שהטבלה גדולה מ‑1,000 שורות, וכל עוד אף אחד לא עובד במערכת בזמן שאתם קוראים. שני התנאים האלה כמעט אף פעם לא מתקיימים.

העמוד הזה הוא המימוש שעובד גם כשהם לא: לולאת עימוד עם סמן המשך, בחירת שדות מצומצמת, נסיגה על שגיאות, ונקודת המשך שנשמרת — כך שהריצה הבאה היא סנכרון דלתא ולא משיכה מלאה נוספת.

לפני שמושכים — לספרו

ספירה היא הקריאה הזולה ביותר ב‑API, והיא ההבדל בין “שתי קריאות” ל‑“180 קריאות ותכנון”.

curl -sS -G "https://api.mbapps.co.il/parse/classes/Accounts" \
  -H "X-Parse-Application-Id: $MB_APP_ID" \
  -H "X-Parse-API-Key: $MB_API_KEY" \
  --data-urlencode 'where={"IsAccount":true}' \
  --data-urlencode 'limit=0' \
  --data-urlencode 'count=1'

const params = new URLSearchParams({
  where: '{"IsAccount":true}',
  limit: '0',
  count: '1',
});

const res = await fetch(`https://api.mbapps.co.il/parse/classes/Accounts?${params}`, {
  headers: {
    'X-Parse-Application-Id': process.env.MB_APP_ID,
    'X-Parse-API-Key': process.env.MB_API_KEY,
  },
});
const data = await res.json();   // { results: [], count: 1842 }

import os

import requests

res = requests.get(
    "https://api.mbapps.co.il/parse/classes/Accounts",
    headers={
        "X-Parse-Application-Id": os.environ["MB_APP_ID"],
        "X-Parse-API-Key":        os.environ["MB_API_KEY"],
    },
    params={
        "where": '{"IsAccount":true}',
        "limit": 0,
        "count": 1,
    },
)
data = res.json()   # { "results": [], "count": 1842 }

<?php
$query = http_build_query([
    'where' => '{"IsAccount":true}',
    'limit' => 0,
    'count' => 1,
]);

$ch = curl_init("https://api.mbapps.co.il/parse/classes/Accounts?$query");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'X-Parse-Application-Id: ' . getenv('MB_APP_ID'),
        'X-Parse-API-Key: '        . getenv('MB_API_KEY'),
    ],
]);
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true);   // { "results": [], "count": 1842 }

{ "results": [], "count": 1842 }

limit=0&count=1 מחזיר את הספירה בלי לשלוף שורה אחת (אומת: {"results":[],"count":24} עם API Key). 1,842 רשומות = שתי קריאות של 1,000. 184,000 = 184 קריאות, וכדאי לפרוס אותן על זמן.

הפרמטרים שהדוגמה משתמשת בהם

פרמטר	הערך בדוגמה	למה
`where`	סמן ההמשך: `createdAt > cursor`	מה שהופך את הריצה השנייה לדלתא ולא למשיכה חוזרת
`keys`	רשימה מפורשת של שדות	בטבלה עם 130 שדות זה ההבדל בין מגה‑בייטים לקילו‑בייטים
`order`	`createdAt` (עולה)	מיון יציב — השדה הזה לא משתנה אחרי היצירה
`limit`	`1000`	גודל העמוד המומלץ. השרת אינו אוכף תקרה (אומת: `limit=2000` החזיר 1,100 שורות — באג core-api-04), אבל עמודים גדולים יותר רק מאריכים תשובה וזיכרון. תמיד מפורש
`include`	—	לא בשימוש כאן. ראו מתי כן
`skip`	—	לא בשימוש בכוונה. ראו למה לא skip

הפירוט המלא של כל פרמטר ואופרטור: שאילתות.

למה לא `skip` עמוק

הדפוס הנאיבי הוא limit=1000&skip=0, ואז skip=1000, וכן הלאה. הוא עובד מצוין על טבלה שאף אחד לא נוגע בה, ונשבר בשקט על טבלה חיה:

מה קורה בזמן המשיכה	מה זה עושה ל‑`skip`
איש מכירות יוצר רשומה חדשה	כל הרשומות אחרי נקודת ההכנסה מוסטות באחת — רשומה אחת תיקרא פעמיים או תדולג
מישהו מעדכן רשומה, והמיון הוא לפי `-updatedAt`	הרשומה קופצת לתחילת התוצאות — ואתם מדלגים על אחרת
הטבלה גדולה	`skip=150000` יקר גם בביצועים: השרת עדיין עובר על מה שדילג עליו

הכי גרוע: אין שגיאה. הייצוא מסתיים בהצלחה עם פחות רשומות ממה שיש, ומישהו יגלה את זה חודשיים אחר כך.

הדפוס העמיד — סמן לפי `createdAt`

במקום לספור שורות, זוכרים איפה עצרנו. createdAt נקבע ביצירה ולא משתנה, ולכן הוא סמן יציב:

עמוד 1:  where {}                                       order createdAt  limit 1000
         → 1000 שורות, האחרונה נוצרה ב-2026-03-04T09:12:44.081Z
עמוד 2:  where { createdAt: { $gt: 2026-03-04T09:12:44.081Z } }   ← אותו מיון, אותו limit
         → 842 שורות  ⇒  פחות מ-limit ⇒  זה היה העמוד האחרון

שתי הנקודות שהופכות את זה לעמיד: הכנסה חדשה תמיד נוחתת אחרי הסמן (כי createdAt שלה גדול יותר), ורשומה שהתעדכנה לא זזה במיון. אומת על טבלה של 1,100 שורות: הרצה של אותה לולאה עם limit=500 משכה 500 + 500 + 100, וריצה שנייה מנקודת ההמשך החזירה 0 שורות. עם PAGE_SIZE = 1000 שבקוד למטה אותה טבלה תתחלק ל‑1000 + 100.

הקוד — בחמש שפות

הדוגמה מושכת את כל הלידים שנוצרו מאז נקודת ההמשך השמורה, שומרת את הסמן אחרי כל עמוד, ומטפלת בשגיאות עם נסיגה אקספוננציאלית.

<?php
declare(strict_types=1);

const API        = 'https://api.mbapps.co.il/parse';
const PAGE_SIZE  = 1000;                       // המקסימום של שכבת ה-REST
const CHECKPOINT = __DIR__ . '/.sync-cursor';  // נקודת ההמשך בין ריצות

function headers(): array
{
    return [
        'X-Parse-Application-Id: ' . getenv('MB_APP_ID'),
        'X-Parse-API-Key: '        . getenv('MB_API_KEY'),
    ];
}

/** קריאת GET עם נסיגה אקספוננציאלית על 429 ו-5xx. */
function getWithBackoff(string $url, int $attempts = 5): array
{
    $delay = 0.5;
    for ($i = 0; $i < $attempts; $i++) {
        $ch = curl_init($url);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT        => 30,
            CURLOPT_HTTPHEADER     => headers(),
        ]);
        $body   = curl_exec($ch);
        $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
        curl_close($ch);

        if ($body !== false && $status === 200) {
            return json_decode($body, true) ?: [];
        }
        if ($body !== false && $status < 500 && $status !== 429) {
            throw new RuntimeException("REST $status: $body");   // 400/401 — לא מנסים שוב
        }
        usleep((int) (($delay + mt_rand(0, 300) / 1000) * 1_000_000));
        $delay *= 2;
    }
    throw new RuntimeException('REST failed after retries');
}

/** משיכת כל הלידים שנוצרו אחרי הסמן. מחזירה את הסמן החדש. */
function syncLeads(?string $cursor): ?string
{
    while (true) {
        $where = $cursor
            ? ['createdAt' => ['$gt' => ['__type' => 'Date', 'iso' => $cursor]]]
            : new stdClass();

        $qs = http_build_query([
            'where' => json_encode($where, JSON_UNESCAPED_UNICODE),
            'keys'  => 'Name,PhoneNumber,Email,City,LeadStatusId,createdAt',
            'order' => 'createdAt',            // מיון יציב — לא -createdAt
            'limit' => PAGE_SIZE,              // תמיד מפורש
        ]);

        $rows = getWithBackoff(API . "/classes/Accounts?$qs")['results'] ?? [];
        if (!$rows) return $cursor;

        foreach ($rows as $row) {
            upsertIntoWarehouse($row);         // הכתיבה שלכם, לפי objectId
        }

        $cursor = $rows[count($rows) - 1]['createdAt'];   // מחרוזת ISO שטוחה
        file_put_contents(CHECKPOINT, $cursor);           // שמירה אחרי כל עמוד

        if (count($rows) < PAGE_SIZE) return $cursor;     // העמוד האחרון
    }
}

$cursor = is_file(CHECKPOINT) ? trim((string) file_get_contents(CHECKPOINT)) : null;
syncLeads($cursor !== '' ? $cursor : null);

"""סנכרון יוצא — משיכת כל הלידים שנוצרו מאז הריצה הקודמת."""
import json
import os
import pathlib
import random
import time
from collections.abc import Iterator

import requests

API = "https://api.mbapps.co.il/parse"
PAGE_SIZE = 1000                                   # המקסימום של שכבת ה-REST
CHECKPOINT = pathlib.Path(".sync-cursor")          # נקודת ההמשך בין ריצות
H = {
    "X-Parse-Application-Id": os.environ["MB_APP_ID"],
    "X-Parse-API-Key":        os.environ["MB_API_KEY"],
}


def get_with_backoff(url: str, params: dict, attempts: int = 5) -> dict:
    """GET עם נסיגה אקספוננציאלית על 429 ו-5xx בלבד."""
    delay = 0.5
    for attempt in range(attempts):
        try:
            r = requests.get(url, headers=H, params=params, timeout=30)
        except requests.RequestException:
            if attempt == attempts - 1:
                raise
        else:
            if r.status_code == 200:
                return r.json()
            if r.status_code < 500 and r.status_code != 429:
                r.raise_for_status()               # 400/401 — אין טעם לנסות שוב
        time.sleep(delay + random.random() * 0.3)  # jitter
        delay *= 2
    raise RuntimeError("REST failed after retries")


def iter_since(table: str, cursor: str | None) -> Iterator[tuple[dict, str]]:
    """מייצר (רשומה, הסמן אחרי העמוד שלה) בסדר createdAt עולה."""
    while True:
        where = (
            {"createdAt": {"$gt": {"__type": "Date", "iso": cursor}}} if cursor else {}
        )
        params = {
            "where": json.dumps(where),            # requests מקודד ל-URL
            "keys":  "Name,PhoneNumber,Email,City,LeadStatusId,createdAt",
            "order": "createdAt",                  # מיון יציב
            "limit": PAGE_SIZE,                    # תמיד מפורש
        }
        rows = get_with_backoff(f"{API}/classes/{table}", params)["results"]
        if not rows:
            return

        cursor = rows[-1]["createdAt"]             # מחרוזת ISO שטוחה
        for row in rows:
            yield row, cursor

        if len(rows) < PAGE_SIZE:                  # העמוד האחרון
            return


def main() -> None:
    cursor = CHECKPOINT.read_text().strip() if CHECKPOINT.exists() else None
    last = cursor
    for row, page_cursor in iter_since("Accounts", cursor):
        upsert_into_warehouse(row)                 # הכתיבה שלכם, לפי objectId
        last = page_cursor
    if last and last != cursor:
        CHECKPOINT.write_text(last)                # שמירה בסוף הריצה


if __name__ == "__main__":
    main()

// סנכרון יוצא — משיכת כל הלידים שנוצרו מאז הריצה הקודמת
import { readFile, writeFile } from 'node:fs/promises';

const API = 'https://api.mbapps.co.il/parse';
const PAGE_SIZE = 1000;                       // המקסימום של שכבת ה-REST
const CHECKPOINT = '.sync-cursor';            // נקודת ההמשך בין ריצות
const H = {
  'X-Parse-Application-Id': process.env.MB_APP_ID,
  'X-Parse-API-Key': process.env.MB_API_KEY,
};

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function getWithBackoff(url, attempts = 5) {
  let delay = 500;
  for (let i = 0; i < attempts; i++) {
    try {
      const res = await fetch(url, { headers: H, signal: AbortSignal.timeout(30_000) });
      if (res.ok) return res.json();
      if (res.status < 500 && res.status !== 429) {
        throw new Error(`REST ${res.status}: ${await res.text()}`);   // לא מנסים שוב
      }
    } catch (err) {
      if (i === attempts - 1) throw err;
    }
    await sleep(delay + Math.random() * 300);   // jitter
    delay *= 2;
  }
  throw new Error('REST failed after retries');
}

async function* iterSince(table, cursor) {
  for (;;) {
    const where = cursor
      ? { createdAt: { $gt: { __type: 'Date', iso: cursor } } }
      : {};

    const qs = new URLSearchParams({
      where: JSON.stringify(where),             // URLSearchParams מקודד עבורכם
      keys: 'Name,PhoneNumber,Email,City,LeadStatusId,createdAt',
      order: 'createdAt',                       // מיון יציב
      limit: String(PAGE_SIZE),                 // תמיד מפורש
    });

    const { results } = await getWithBackoff(`${API}/classes/${table}?${qs}`);
    if (!results.length) return;

    cursor = results[results.length - 1].createdAt;   // מחרוזת ISO שטוחה
    for (const row of results) yield { row, cursor };

    if (results.length < PAGE_SIZE) return;           // העמוד האחרון
  }
}

const start = await readFile(CHECKPOINT, 'utf8').catch(() => null);
let last = start;

for await (const { row, cursor } of iterSince('Accounts', start?.trim() || null)) {
  await upsertIntoWarehouse(row);               // הכתיבה שלכם, לפי objectId
  last = cursor;
}

if (last && last !== start) await writeFile(CHECKPOINT, last, 'utf8');

// סנכרון יוצא — משיכת כל הלידים שנוצרו מאז הריצה הקודמת
using System.Net;
using System.Net.Http.Json;
using System.Runtime.CompilerServices;
using System.Text.Json;
using System.Web;

public sealed class OutboundSync(HttpClient http)
{
    private const string Api = "https://api.mbapps.co.il/parse";
    private const int PageSize = 1000;                    // המקסימום של שכבת ה-REST
    private const string Checkpoint = ".sync-cursor";     // נקודת ההמשך בין ריצות

    private async Task<JsonElement> GetWithBackoffAsync(string url, CancellationToken ct)
    {
        var delay = TimeSpan.FromMilliseconds(500);
        for (var attempt = 0; attempt < 5; attempt++)
        {
            using var res = await http.GetAsync(url, ct);
            if (res.IsSuccessStatusCode)
                return await res.Content.ReadFromJsonAsync<JsonElement>(cancellationToken: ct);

            var status = (int)res.StatusCode;
            if (status < 500 && res.StatusCode != HttpStatusCode.TooManyRequests)
                throw new HttpRequestException($"REST {status}: {await res.Content.ReadAsStringAsync(ct)}");

            await Task.Delay(delay + TimeSpan.FromMilliseconds(Random.Shared.Next(300)), ct);
            delay *= 2;
        }
        throw new HttpRequestException("REST failed after retries");
    }

    /// <summary>מייצר את כל הרשומות שנוצרו אחרי הסמן, בסדר createdAt עולה.</summary>
    public async IAsyncEnumerable<(JsonElement Row, string Cursor)> IterSinceAsync(
        string table, string? cursor, [EnumeratorCancellation] CancellationToken ct = default)
    {
        while (true)
        {
            var where = cursor is null
                ? "{}"
                : $$"""{"createdAt":{"$gt":{"__type":"Date","iso":"{{cursor}}"}}}""";

            var qs = HttpUtility.ParseQueryString(string.Empty);
            qs["where"] = where;                                  // מקודד אוטומטית
            qs["keys"]  = "Name,PhoneNumber,Email,City,LeadStatusId,createdAt";
            qs["order"] = "createdAt";                            // מיון יציב
            qs["limit"] = PageSize.ToString();                    // תמיד מפורש

            var doc = await GetWithBackoffAsync($"{Api}/classes/{table}?{qs}", ct);
            var results = doc.GetProperty("results");
            var count = results.GetArrayLength();
            if (count == 0) yield break;

            cursor = results[count - 1].GetProperty("createdAt").GetString()!;
            foreach (var row in results.EnumerateArray()) yield return (row, cursor);

            if (count < PageSize) yield break;                    // העמוד האחרון
        }
    }

    public async Task RunAsync(CancellationToken ct = default)
    {
        var start = File.Exists(Checkpoint) ? (await File.ReadAllTextAsync(Checkpoint, ct)).Trim() : null;
        var last = start;

        await foreach (var (row, cursor) in IterSinceAsync("Accounts", start, ct))
        {
            await UpsertIntoWarehouseAsync(row, ct);              // הכתיבה שלכם, לפי objectId
            last = cursor;
        }

        if (last is not null && last != start)
            await File.WriteAllTextAsync(Checkpoint, last, ct);
    }
}

הכותרות נקבעות פעם אחת על ה‑HttpClient שמוזרק פנימה:

http.DefaultRequestHeaders.Add("X-Parse-Application-Id", appId);
http.DefaultRequestHeaders.Add("X-Parse-API-Key", apiKey);   // ממנהל סודות
http.Timeout = TimeSpan.FromSeconds(30);

// מסך מצב — קורא מהשרת שלכם, לא מ-api.mbapps.co.il
async function renderSyncStatus() {
  const res = await fetch('/api/sync/status');
  if (!res.ok) throw new Error('שגיאה בטעינת מצב הסנכרון');

  const { lastRunAt, cursor, rowsPulled, lastError } = await res.json();

  document.getElementById('sync-status').textContent = lastError
    ? `הריצה האחרונה נכשלה: ${lastError}`
    : `סונכרנו ${rowsPulled} רשומות · נקודת המשך: ${cursor} · ${lastRunAt}`;
}

setInterval(renderSyncStatus, 30_000);
renderSyncStatus();

ואם באמת צריך להציג נתונים מהמערכת בדף — נקודת קצה בשרת שמחזירה בדיוק את מה שמותר לפרסם, ומגבילה את הכמות בעצמה:

// בדפדפן
const leads = await fetch('/api/leads?limit=20').then((r) => r.json());

מה קורה כשהטבלה משתנה תוך כדי המשיכה

מה קורה במערכת	מה קורה למשיכה שלכם	האם צריך לעשות משהו
נוצרות רשומות חדשות	הן נוחתות אחרי הסמן ונקראות בעמוד הבא, או בריצה הבאה	לא — זו התנהגות רצויה
רשומה קיימת מתעדכנת	היא לא תיקרא שוב — הסמן הוא `createdAt`	כן, אם אתם צריכים עדכונים. ראו סנכרון עדכונים
רשומה נמחקת	המשיכה לעולם לא תדע על כך	כן. ראו מה משיכה לא תראה
שתי רשומות נוצרות באותה מילישנייה	`$gt` על הסמן ידלג על השנייה	כן, בטבלאות עמוסות. ראו למטה
ההרשאות של הטבלה משתנות באמצע	חלק מהשורות פשוט לא יחזרו — בלי שגיאה	כן — השוו את הספירה בסוף

$gt על הסמן מדלג על כל רשומה שנוצרה בדיוק באותה מילישנייה כמו הרשומה האחרונה בעמוד. בטבלה שנכתבת בקצב איטי זה לא יקרה; בטעינה המונית או בטופס שנשלח בכמות — כן. אומת: אחרי טעינה ב‑batch, 1,100 שורות חלקו רק 19 חותמות זמן שונות (עד 100 שורות לחותמת); $gt על אחת מהן החזיר 1,064 שורות, $gte — 1,100.

התיקון: החליפו ל‑$gte וסננו כפילויות לפי objectId — שמרו את מזהי העמוד האחרון והשמיטו אותם מהעמוד הבא. עלות: כמה שורות שנקראות פעמיים. תמורה: אף שורה לא נעלמת.

# וריאנט עמיד: $gte + סינון כפילויות לפי objectId
where = {"createdAt": {"$gte": {"__type": "Date", "iso": cursor}}} if cursor else {}
rows = get_with_backoff(f"{API}/classes/{table}", params)["results"]
fresh = [r for r in rows if r["objectId"] not in seen_ids_of_previous_page]
seen_ids_of_previous_page = {r["objectId"] for r in rows if r["createdAt"] == rows[-1]["createdAt"]}

סנכרון עדכונים — `updatedAt` במקום `createdAt`

אם המערכת היעד צריכה גם שינויים ולא רק רשומות חדשות, החליפו את שדה הסמן:

הסמן	תופס	לא תופס	המחיר
`createdAt`	רשומות חדשות	עדכונים, מחיקות	סמן יציב לחלוטין
`updatedAt`	חדשות וגם מעודכנות	מחיקות	אותה רשומה תחזור בכל ריצה שבה עודכנה — חתכו כפילויות לפי `objectId` בצד שלכם, ובצעו upsert ולא insert

עם updatedAt המיון כבר אינו יציב: רשומה שמתעדכנת בזמן המשיכה זזה קדימה. הסמן מגן עליכם מ“דילוג”, אבל לא מ“קריאה כפולה” — ולכן הכתיבה בצד שלכם חייבת להיות אידמפוטנטית, לפי objectId.

מה משיכה לעולם לא תראה

משיכה מבוססת שאילתה מחזירה רק מה שקיים. רשומה שנמחקה פשוט מפסיקה להופיע — וקוד שמסנכרן דלתא לא יראה כלום.

גרוע מזה: שורת המחיקה ביומן מצומצמת ואינה כוללת את הערכים שנמחקו, ולכן גם “לחפש מחיקות ביומן” אינו פתרון מלא.

מה שעובד: לבקש מהלקוח דפוס של ביטול/ארכיון במקום מחיקה (שדה IsCanceled / ArchivedAt), שאותו המשיכה כן רואה. אם זה לא אפשרי — השוו מדי פעם ספירה מלאה מול המחסן, או משכו את רשימת ה‑objectId בלבד (keys=objectId) ומחקו אצלכם מה שנעלם. זו קריאה זולה יחסית, אבל היא לא דלתא.

בנוסף, שדות שההרשאות מסתירות פשוט לא יחזרו, בלי שגיאה, ורשומה שאינה נראית להרשאה שלכם תיראה כמו רשומה שלא קיימת (code 101). עם API Key זה לא רלוונטי (הוא עוקף הכול — אומת: קריאה ל‑_User עם API Key מחזירה 200), אבל עם Session Token — כן. ראו אימות.

ומה שכן מגן עליכם ממחיקות חלקית: בטננט חדש מופעל checkDependenciesBeforeDelete, ולכן מחיקה של רשומה שיש אליה Pointer נחסמת (400 code 119 Pointer to Object … exists in table Tasks in key AccountId. Delete is not allowed. — אומת). רשומות שאין אליהן הפניות עדיין נעלמות בשקט.

`include` — מתי שווה לשלם עליו

הדוגמה לא משתמשת ב‑include. הסיבה: היא שולפת את שדה ה‑Pointer (LeadStatusId) כמצביע, ומתרגמת אותו במחסן מול טבלת הסטטוסים שנמשכה פעם אחת.

המצב	מה עדיף
טבלת lookup קטנה וקבועה (סטטוסים, מקורות, ערים)	משכו אותה פעם אחת לזיכרון ותרגמו אצלכם. אל תשלמו `include` על כל שורה
Pointer לטבלה גדולה שאתם צריכים ממנה 2–3 שדות	`include` — הוא חוסך קריאת N+1 לכל שורה
Pointer שאתם רק מעבירים הלאה כמזהה	בלי `include` — המזהה כבר בתשובה

המגבלות שהדוגמה מכבדת

המגבלה	הערך	איך הדוגמה מתמודדת
`limit` ברירת מחדל ב‑REST	100	מציינת `limit` במפורש, תמיד
`limit` מרבי ב‑REST	אין תקרה נאכפת — `limit=2000` החזיר את כל 1,100 השורות (באג core-api-04); 1000 הוא המלצה	`PAGE_SIZE = 1000` — גודל עמוד, לא מגבלת שרת
`where` הוא JSON שעובר URL‑encoding	—	קידוד דרך הספרייה, לא שרשור מחרוזות
`$or` תקף רק ברמה העליונה (או בתוך `$and`)	—	אומת: `$or` בתוך שדה → `400 code 107 bad constraint: $or`; בתוך `$and` עובד. לא בשימוש כאן; ראו שאילתות
אגרגציה	—	`/parse/aggregate/…` (כולל `distinct`) אינו קיים בפריסה — 404 גם עם Master Key (באג core-api-01). הנתיב הפנימי `/parse/classes-aggregate/…` עונה גם ל‑API Key. הדוגמה מושכת שורות; לסכומים — אגרגציות
מגבלות קצב	אין מגבלה מתועדת, ולא נצפתה — 150 קריאות במקביל (1.2 שניות) ועוד 100 עוקבות (2.2 שניות) חזרו כולן `200`, בלי `429`	נסיגה אקספוננציאלית + jitter, והשהיה מרצון בטעינות גדולות

צ’קליסט לפני שמריצים על ייצור

המשך

שאילתות — כל פרמטר, כל אופרטור, וסעיף העימוד המלא
עבודה עם רשומות — הצד הכותב
אגרגציות — כשצריך סכום ולא רשימה
מגבלות ומכסות — כל המספרים במקום אחד
יומנים וראיות — מה מתועד ומה לא, כולל מחיקות
מצא‑או‑צור ורשומה מקושרת — הצד הכותב של אותה אינטגרציה
דוגמאות קוד — הקטלוג המלא