# API Maker benchmark : 4 vCPU, 8 GB RAM (Linode shared CPU) > API Maker on 4 shared vCPUs, 8 GB (Linode) : 7,423 req/s get all, 26,444 cached, on MongoDB, PostgreSQL and MySQL, with memory and autocannon output. Source: https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html Benchmark · Linode (Akamai Cloud) · Shared CPU · 12 October 2026 **4 vCPU, 8 GB RAM : 7,423 to 9,375 requests per second for a whole table.** API Maker 4.0.0 on a Linode 8 GB (g6-standard-4) : 4 shared vCPUs and 8 GB of RAM at $48 a month, its databases on the same machine. Every API was loaded for 15 seconds by autocannon from a second server, two times, on MongoDB, PostgreSQL and MySQL, public and with two tokens, while the server sampled the memory and CPU of every part each second. Get all · MongoDB 7,423req/s PostgreSQL 8,395 · MySQL 9,375 Get by id, cached 26,444req/s answered from Redis · PostgreSQL 26,617 · MySQL 27,185 Custom API · MongoDB 5,178req/s TypeScript, lean : run in the server · in the sandbox 4,649 API Maker memory 109MB at rest · 142 MB at most under load ## The server | | | |---|---| | Server | Linode (Akamai Cloud), Linode 8 GB (g6-standard-4), shared cpu, $48 / month | | CPU | AMD EPYC 7642 48-Core Processor, 4 shared vCPUs (KVM)
KVM guest, 1 thread per core · L1d 256 KiB (4 instances) · L2 2 MiB (4 instances) · L3 64 MiB (4 instances) · BogoMIPS 4599.99 | | Memory | 8 GB (7,941 MB usable), swap 8.3 GB (496 MB of Linode + 7.8 GB made by the installer) | | Disk, region | 160 GB SSD, Mumbai, India (ap-west) | | System | Ubuntu 24.04.4 LTS, Linux 6.8.0-134, Docker 29.9.0 | | API Maker | 4.0.0 : release build of api_maker_be_rust 864bb64 (opt-level 3, fat LTO), installed by its installer (https://apimaker.dev/v4/install.sh), no reverse proxy | | Settings | the defaults of the installer (lean code of the account runs in the server with QuickJS : sandbox.codeInServer), and the sandboxes kept running for the whole run (removeSandboxInactiveSinceMinutes 1440) | | Databases | MongoDB 8.0.10 (the MongoDB of API Maker, a replica set of one member, in Docker) · Redis 7.0.5 (the Redis of API Maker, in Docker) · PostgreSQL 18.6 (official image postgres:18, max_connections 500) · MySQL 8.4.11 (official image mysql:8.4, max_connections 500) : all on the same server | | Sandboxes | TypeScript on Node.js 24.21.0 (an image of 403 MB built by API Maker), 2 sandboxes of the account (sandboxCountForAdmin 2, the default), each opening up to 4 runners when it is busy (one per vCPU) | | Load generator | Dedicated 32 GB (g6-dedicated-16) : AMD EPYC 7713 64-Core Processor, 16 dedicated vCPUs, Ubuntu 24.04.4 LTS, Node.js 24.21.0, autocannon 8.0.0 with 10 worker threads | | Network | Private network of the same data centre, round trip 0.42 ms (ping) | | Host | A strict anti-affinity placement group kept the three shared CPU servers (2, 4 and 8 vCPUs) on three different hosts. All seven servers were measured at the same time, each by a load generator of its own. | | Date | 12 October 2026, 05:30 to 06:44 UTC | Only what a database needs was running while it was measured : API Maker and its two sandboxes, its MongoDB and Redis (API Maker always needs them) and the database under test. The other benchmark databases were stopped, API Maker was restarted and the swap emptied back into memory before each database, when it fitted there. How every number was taken : [How API Maker is benchmarked](https://docs.apimaker.dev/v4/docs/benchmarks/methodology.html). Every server side by side : [All results](https://docs.apimaker.dev/v4/docs/benchmarks/summary.html). ## The data Every table holds the ten rows of the [API Maker benchmark dataset](https://apimaker.dev/json/benchmark_dataset.json) : `https://apimaker.dev/json/benchmark_dataset.json`. Ten customers, ten columns each ; a *get all* answers all ten (2,418 bytes of JSON on MongoDB), a *get by id* one of them. | `_id` | `customer_id` | `first_name` | `last_name` | `phone` | `last_update` | `pincode` | `shipping_id` | `dob` | `country` | |---|---|---|---|---|---|---|---|---|---| | 60ae2488c37cd955cc144161 | 2 | NICK | WAHLBERG | 1123456789 | 2006-02-15T04:34:00.330Z | 111111 | 2 | 2022-10-30T03:25:03.000Z | India | | 60ae24c8c37cd955cc144162 | 1 | PENELOPE | GUINESS | 123456789 | 2006-02-15T04:34:00.330Z | 100050 | 1 | 2022-10-30T03:25:03.000Z | India | | 60ae247ac37cd955cc144160 | 3 | ED | CHASE | 2123456789 | 2006-02-15T04:34:00.330Z | 222222 | 3 | 2022-10-30T03:25:03.000Z | India | | 60ace1401efc56684403c68c | 4 | JENNIFER | DAVIS | 3123456789 | 2006-02-15T04:34:00.330Z | 100050 | 4 | 2022-10-30T03:25:03.000Z | India | | 60accda51efc56684403c685 | 5 | JOHNNY | LOLLOBRIGIDA | 4123456789 | 2006-02-15T04:34:00.330Z | 485125 | 1 | 2022-10-30T03:25:03.000Z | India | | 606b7d364bebce00196eade7 | 6 | JOHNNY | LOLLOBRIGIDA | 5123456789 | 2006-02-15T04:34:00.330Z | 123456 | 2 | 2022-10-30T03:25:03.000Z | India | | 606b75961055000018fa9d98 | 7 | GRACE | MOSTEL | 6123456789 | 2006-02-15T04:34:00.330Z | 356589 | 3 | 2022-10-30T03:25:03.000Z | India | | 6064dd02730026001956663e | 8 | MATTHEW | JOHANSSON | 7123456789 | 2006-02-15T04:34:00.330Z | 100050 | 4 | 2022-10-30T03:25:03.000Z | India | | 6064dcb8730026001956663c | 9 | JOE | SWANK | 8123456789 | 2006-02-15T04:34:00.330Z | 251415 | 1 | 2022-10-30T03:25:03.000Z | India | | 6064c4c02bafb90018955299 | 10 | CHRISTIAN | GABLE | 9123456789 | 2006-02-15T04:34:00.330Z | 100050 | | 2022-10-30T03:25:03.000Z | India | ## Results at a glance Requests per second, the average of two rounds of 15 seconds with 100 connections. *Public* APIs need no token ; *both tokens* means every request carries `x-am-authorization` (the token of an API user, whose groups decide what it may call) and `x-am-user-authorization` (the token of a row of the `customers` table, made by a DB token generator), and API Maker checks both. **Requests per second · 4 vCPU, 8 GB RAM, shared CPU** · MongoDB · PostgreSQL · MySQL Get allpublic · 7,423 · 8,395 · 9,375 Get allboth tokens · 7,021 · 7,680 · 8,338 Get all with cachingpublic · 26,115 · 26,420 · 25,630 Get all with cachingboth tokens · 20,550 · 20,113 · 20,763 Get all by streampublic · 6,724 · 8,226 · 8,355 Get all by streamboth tokens · 6,737 · 7,486 · 7,469 Custom API calling get all QuickJS · public · 5,178 · 5,658 · 6,016 Custom API calling get all QuickJS · both tokens · 4,910 · 5,158 · 5,536 Custom API in the sandbox Sandbox · public · 4,649 · 5,126 · 5,486 Get all with a pre hook QuickJS · both tokens · 5,327 · 6,151 · 6,768 Get by idpublic · 8,076 · 9,446 · 9,893 Get by idboth tokens · 7,513 · 8,233 · 8,892 Get by id with cachingpublic · 26,444 · 26,617 · 27,185 Get by id with cachingboth tokens · 20,887 · 21,238 · 22,684 Insert one rowpublic · 3,198 · 3,969 · 3,181 | API | Access | MongoDB | PostgreSQL | MySQL | |---|---|--:|--:|--:| | [Get all](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-all) | Public | **7,423** p99 28 ms | **8,395** p99 14 ms | **9,375** p99 12 ms | | [Get all](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-all) | Both tokens | **7,021** p99 28 ms | **7,680** p99 15 ms | **8,338** p99 17 ms | | [Get all with caching](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-all-with-caching) | Public | **26,115** p99 5 ms | **26,420** p99 5 ms | **25,630** p99 6 ms | | [Get all with caching](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-all-with-caching) | Both tokens | **20,550** p99 7 ms | **20,113** p99 8 ms | **20,763** p99 7 ms | | [Get all by stream](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-all-by-stream) | Public | **6,724** p99 33 ms | **8,226** p99 14 ms | **8,355** p99 14 ms | | [Get all by stream](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-all-by-stream) | Both tokens | **6,737** p99 29 ms | **7,486** p99 15 ms | **7,469** p99 15 ms | | [Custom API calling get all](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#custom-api-calling-get-all) QuickJS | Public | **5,178** p99 34 ms | **5,658** p99 20 ms | **6,016** p99 19 ms | | [Custom API calling get all](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#custom-api-calling-get-all) QuickJS | Both tokens | **4,910** p99 34 ms | **5,158** p99 22 ms | **5,536** p99 20 ms | | [Custom API in the sandbox](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#custom-api-in-the-sandbox) Sandbox | Public | **4,649** p99 42 ms | **5,126** p99 35 ms | **5,486** p99 33 ms | | [Get all with a pre hook](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-all-with-a-pre-hook) QuickJS | Both tokens | **5,327** p99 34 ms | **6,151** p99 18 ms | **6,768** p99 17 ms | | [Get by id](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-by-id) | Public | **8,076** p99 26 ms | **9,446** p99 12 ms | **9,893** p99 11 ms | | [Get by id](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-by-id) | Both tokens | **7,513** p99 23 ms | **8,233** p99 17 ms | **8,892** p99 13 ms | | [Get by id with caching](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-by-id-with-caching) | Public | **26,444** p99 5 ms | **26,617** p99 5 ms | **27,185** p99 5 ms | | [Get by id with caching](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#get-by-id-with-caching) | Both tokens | **20,887** p99 7 ms | **21,238** p99 7 ms | **22,684** p99 6 ms | | [Insert one row](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#insert-one-row) | Public | **3,198** p99 63 ms | **3,969** p99 28 ms | **3,181** p99 35 ms | | [Custom API without a database](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#custom-api-without-a-database) | Public | **26,046** p99 6 ms | | | | [Custom API without a database, in the sandbox](https://docs.apimaker.dev/v4/docs/benchmarks/linode-shared-4-vcpu-8gb.html#custom-api-without-a-database) | Public | **17,702** p99 10 ms | | | (0 errors) Every one of the **19,370,117 requests** of these runs was answered with status 200 or 201 : no error, no timeout. ## Memory What each part of the server held, in MB : at rest (the 60 seconds after API Maker and its sandboxes started, before any request) and under load. The bars show the second the whole server held the most memory while its database was loaded, out of the 7,941 MB of the server ; the table gives the most each part held on its own. API Maker is the resident memory of its process ; a container is counted the way `docker stats` counts it. API Maker · MongoDB of API Maker · Redis · PostgreSQL / MySQL · Sandboxes · Linux, Docker, the rest · Available MongoDB at rest under load PostgreSQL at rest under load MySQL at rest under load | Part | MongoDB
at rest → under load | PostgreSQL
at rest → under load | MySQL
at rest → under load | |---|--:|--:|--:| | **API Maker** (process), in RAM | 109 → **135** | 103 → **135** | 107 → **142** | | … and in swap | 0 → **0** | 0 → **0** | 0 → **0** | | MongoDB of API Maker, in RAM | 125 → **290** | 276 → **276** | 275 → **276** | | … and in swap | 0 → **0** | 0 → **0** | 0 → **0** | | Redis, in RAM | 3 → **4** | 3 → **4** | 3 → **4** | | Database under test, in RAM | MongoDB above | 38 → **211** | 421 → **507** | | … and in swap | MongoDB above | 0 → **0** | 0 → **0** | | Sandboxes (2 containers), in RAM | 55 → **602** | 55 → **545** | 55 → **520** | | … and in swap | 0 → **0** | 0 → **0** | 0 → **0** | | **Whole server**, RAM used | 872 → **1593** | 1081 → **1761** | 1462 → **2048** | | Swap used | 0 → **0** | 0 → **0** | 0 → **0** | ## CPU On 4 vCPUs, API Maker, the database and the sandboxes share the same 4 vCPUs : every request costs the work of all of them. During *get all, public*, the CPU was split this way (average of the 15 seconds, in vCPUs : 4.0 is the whole server ; a process counts its own kernel time) : | | MongoDB | PostgreSQL | MySQL | |---|--:|--:|--:| | API Maker | 1.6 vCPU | 1.9 vCPU | 2.0 vCPU | | The database | 1.8 vCPU | 1.0 vCPU | 0.9 vCPU | | MongoDB of API Maker (when it is not the one tested) | – | 0.0 vCPU | 0.0 vCPU | | Sandboxes (idle : no code runs in get all) | 0.0 vCPU | 0.0 vCPU | 0.0 vCPU | | Whole server busy (of its 4 vCPUs) | 99 % | 90 % | 91 % | | … of which kernel time (network, disk), counted in the lines above too | 31 % | 35 % | 36 % | Steal time (CPU the hypervisor gave to other servers) was 0 % on average, 0 % at most. The load generator, sampled the same way, was never more than 21 % busy over its 16 cores : it was never the limit. ## Get all The schema API of a table answers all its rows : `GET /api/schema////`. Every request reads the ten rows from the database, converts them with the schema of the table and sends them as JSON. [About this API](https://docs.apimaker.dev/v4/docs/apis-all/schema-apis/auto-generated-schema-based-get-all-api.html). ### Get all : public No token : the API is public. Each answer : 2,418 bytes (MongoDB), status 200. **MongoDB** Requests / second 7,423 119,615 requests in 15 s Latency p50 11ms average 12.0 ms Latency p99 28ms max 68 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **7,974** · 2 : **6,873** req/s · spread 14.8 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.6 vCPU**, **123 MB** RSS · MongoDB **1.8 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **99 %**, of which kernel (network, disk) **31 %** · memory used **902 MB** of 7942 MB · steal **0 %** · swap not touched autocannon · MongoDB · get all, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 5 ms │ 11 ms │ 23 ms │ 28 ms │ 12.04 ms │ 4.76 ms │ 68 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 7,259 │ 7,259 │ 7,907 │ 8,847 │ 7,973.87 │ 547.28 │ 7,258 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 19.9 MB │ 19.9 MB │ 21.6 MB │ 24.2 MB │ 21.8 MB │ 1.5 MB │ 19.9 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 4 │ ├────────────┼──────────────┤ │ 2.5 │ 5 │ ├────────────┼──────────────┤ │ 10 │ 7 │ ├────────────┼──────────────┤ │ 25 │ 9 │ ├────────────┼──────────────┤ │ 50 │ 11 │ ├────────────┼──────────────┤ │ 75 │ 14 │ ├────────────┼──────────────┤ │ 90 │ 17 │ ├────────────┼──────────────┤ │ 97.5 │ 23 │ ├────────────┼──────────────┤ │ 99 │ 28 │ ├────────────┼──────────────┤ │ 99.9 │ 44 │ ├────────────┼──────────────┤ │ 99.99 │ 55 │ ├────────────┼──────────────┤ │ 99.999 │ 66 │ └────────────┴──────────────┘ 120k requests in 15.02s, 327 MB read ``` **PostgreSQL** Requests / second 8,395 127,345 requests in 15 s Latency p50 11ms average 11.3 ms Latency p99 14ms max 20 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **8,489** · 2 : **8,300** req/s · spread 2.3 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.9 vCPU**, **115 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **1.0 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **90 %**, of which kernel (network, disk) **35 %** · memory used **1093 MB** of 7942 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get all, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 10 ms │ 11 ms │ 13 ms │ 14 ms │ 11.28 ms │ 1.02 ms │ 20 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 8,279 │ 8,279 │ 8,471 │ 8,815 │ 8,489.34 │ 135.82 │ 8,276 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 20.1 MB │ 20.1 MB │ 20.5 MB │ 21.4 MB │ 20.6 MB │ 330 kB │ 20.1 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 9 │ ├────────────┼──────────────┤ │ 2.5 │ 10 │ ├────────────┼──────────────┤ │ 10 │ 10 │ ├────────────┼──────────────┤ │ 25 │ 11 │ ├────────────┼──────────────┤ │ 50 │ 11 │ ├────────────┼──────────────┤ │ 75 │ 12 │ ├────────────┼──────────────┤ │ 90 │ 12 │ ├────────────┼──────────────┤ │ 97.5 │ 13 │ ├────────────┼──────────────┤ │ 99 │ 14 │ ├────────────┼──────────────┤ │ 99.9 │ 15 │ ├────────────┼──────────────┤ │ 99.99 │ 19 │ ├────────────┼──────────────┤ │ 99.999 │ 20 │ └────────────┴──────────────┘ 127k requests in 15.02s, 309 MB read ``` **MySQL** Requests / second 9,375 140,877 requests in 15 s Latency p50 10ms average 10.2 ms Latency p99 12ms max 23 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **9,393** · 2 : **9,358** req/s · spread 0.4 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.0 vCPU**, **117 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.9 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **91 %**, of which kernel (network, disk) **36 %** · memory used **1472 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get all, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 9 ms │ 10 ms │ 12 ms │ 12 ms │ 10.15 ms │ 0.93 ms │ 23 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤ │ Req/Sec │ 9,223 │ 9,223 │ 9,407 │ 9,615 │ 9,392.8 │ 85.71 │ 9,218 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤ │ Bytes/Sec │ 22.3 MB │ 22.3 MB │ 22.8 MB │ 23.3 MB │ 22.8 MB │ 209 kB │ 22.3 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 9 │ ├────────────┼──────────────┤ │ 2.5 │ 9 │ ├────────────┼──────────────┤ │ 10 │ 9 │ ├────────────┼──────────────┤ │ 25 │ 10 │ ├────────────┼──────────────┤ │ 50 │ 10 │ ├────────────┼──────────────┤ │ 75 │ 11 │ ├────────────┼──────────────┤ │ 90 │ 11 │ ├────────────┼──────────────┤ │ 97.5 │ 12 │ ├────────────┼──────────────┤ │ 99 │ 12 │ ├────────────┼──────────────┤ │ 99.9 │ 14 │ ├────────────┼──────────────┤ │ 99.99 │ 19 │ ├────────────┼──────────────┤ │ 99.999 │ 22 │ └────────────┴──────────────┘ 141k requests in 15.02s, 341 MB read ``` ### Get all : both tokens With `x-am-authorization` and `x-am-user-authorization`, both checked on every request. Each answer : 2,418 bytes (MongoDB), status 200. **MongoDB** Requests / second 7,021 102,801 requests in 15 s Latency p50 14ms average 14.1 ms Latency p99 28ms max 66 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **7,187** · 2 : **6,854** req/s · spread 4.7 % · the output below is round 2, the closer to the average (Server during this run) API Maker **1.9 vCPU**, **131 MB** RSS · MongoDB **1.5 vCPU** · sandboxes **0.0 vCPU**, **582 MB** · whole server busy **99 %**, of which kernel (network, disk) **29 %** · memory used **1576 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get all, both tokens · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 6 ms │ 14 ms │ 25 ms │ 28 ms │ 14.09 ms │ 4.74 ms │ 66 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤ │ Req/Sec │ 6,679 │ 6,679 │ 6,895 │ 7,035 │ 6,854 │ 126.08 │ 6,676 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤ │ Bytes/Sec │ 18.3 MB │ 18.3 MB │ 18.9 MB │ 19.3 MB │ 18.7 MB │ 346 kB │ 18.3 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 5 │ ├────────────┼──────────────┤ │ 2.5 │ 6 │ ├────────────┼──────────────┤ │ 10 │ 9 │ ├────────────┼──────────────┤ │ 25 │ 11 │ ├────────────┼──────────────┤ │ 50 │ 14 │ ├────────────┼──────────────┤ │ 75 │ 17 │ ├────────────┼──────────────┤ │ 90 │ 20 │ ├────────────┼──────────────┤ │ 97.5 │ 25 │ ├────────────┼──────────────┤ │ 99 │ 28 │ ├────────────┼──────────────┤ │ 99.9 │ 41 │ ├────────────┼──────────────┤ │ 99.99 │ 53 │ ├────────────┼──────────────┤ │ 99.999 │ 64 │ └────────────┴──────────────┘ 103k requests in 15.01s, 281 MB read ``` **PostgreSQL** Requests / second 7,680 117,913 requests in 15 s Latency p50 12ms average 12.2 ms Latency p99 15ms max 24 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **7,862** · 2 : **7,498** req/s · spread 4.7 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.1 vCPU**, **117 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.9 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **91 %**, of which kernel (network, disk) **33 %** · memory used **1097 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get all, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 11 ms │ 12 ms │ 14 ms │ 15 ms │ 12.22 ms │ 1.08 ms │ 24 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 7,575 │ 7,575 │ 7,915 │ 8,043 │ 7,861.47 │ 155.08 │ 7,572 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 18.4 MB │ 18.4 MB │ 19.2 MB │ 19.5 MB │ 19.1 MB │ 375 kB │ 18.4 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 10 │ ├────────────┼──────────────┤ │ 2.5 │ 11 │ ├────────────┼──────────────┤ │ 10 │ 11 │ ├────────────┼──────────────┤ │ 25 │ 12 │ ├────────────┼──────────────┤ │ 50 │ 12 │ ├────────────┼──────────────┤ │ 75 │ 13 │ ├────────────┼──────────────┤ │ 90 │ 13 │ ├────────────┼──────────────┤ │ 97.5 │ 14 │ ├────────────┼──────────────┤ │ 99 │ 15 │ ├────────────┼──────────────┤ │ 99.9 │ 16 │ ├────────────┼──────────────┤ │ 99.99 │ 21 │ ├────────────┼──────────────┤ │ 99.999 │ 22 │ └────────────┴──────────────┘ 118k requests in 15.02s, 286 MB read ``` **MySQL** Requests / second 8,338 122,715 requests in 15 s Latency p50 12ms average 11.7 ms Latency p99 17ms max 25 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **8,181** · 2 : **8,494** req/s · spread 3.8 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.2 vCPU**, **121 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.8 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **93 %**, of which kernel (network, disk) **34 %** · memory used **1480 MB** of 7942 MB · steal **0 %** · swap not touched autocannon · MySQL · get all, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 10 ms │ 12 ms │ 15 ms │ 17 ms │ 11.73 ms │ 1.34 ms │ 25 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬───────┬───────┬─────────┬─────────┬──────────┬────────┬───────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼───────┼───────┼─────────┼─────────┼──────────┼────────┼───────┤ │ Req/Sec │ 7,431 │ 7,431 │ 8,223 │ 8,551 │ 8,181.07 │ 269.14 │ 7,431 │ ├───────────┼───────┼───────┼─────────┼─────────┼──────────┼────────┼───────┤ │ Bytes/Sec │ 18 MB │ 18 MB │ 19.9 MB │ 20.7 MB │ 19.8 MB │ 653 kB │ 18 MB │ └───────────┴───────┴───────┴─────────┴─────────┴──────────┴────────┴───────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 10 │ ├────────────┼──────────────┤ │ 2.5 │ 10 │ ├────────────┼──────────────┤ │ 10 │ 11 │ ├────────────┼──────────────┤ │ 25 │ 11 │ ├────────────┼──────────────┤ │ 50 │ 12 │ ├────────────┼──────────────┤ │ 75 │ 12 │ ├────────────┼──────────────┤ │ 90 │ 13 │ ├────────────┼──────────────┤ │ 97.5 │ 15 │ ├────────────┼──────────────┤ │ 99 │ 17 │ ├────────────┼──────────────┤ │ 99.9 │ 21 │ ├────────────┼──────────────┤ │ 99.99 │ 24 │ ├────────────┼──────────────┤ │ 99.999 │ 25 │ └────────────┴──────────────┘ 123k requests in 15.01s, 297 MB read ``` ## Get all with caching The same request on a table whose API settings say `enableCaching: true`. The first answer is kept in Redis, under a key made of who asks and what is asked ; the next requests are answered from Redis until the answer expires or something writes the table. [About this API](https://docs.apimaker.dev/v4/docs/features/automatic-caching.html). ### Get all with caching : public No token : the API is public. Each answer : 2,418 bytes (MongoDB), status 200. **MongoDB** Requests / second 26,115 399,054 requests in 15 s Latency p50 3ms average 3.3 ms Latency p99 5ms max 17 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **26,609** · 2 : **25,621** req/s · spread 3.8 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.4 vCPU**, **123 MB** RSS · MongoDB **0.0 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · Redis **0.2 vCPU** · whole server busy **96 %**, of which kernel (network, disk) **31 %** · memory used **905 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get all with caching, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public_cached" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public_cached 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 3 ms │ 5 ms │ 5 ms │ 3.26 ms │ 0.86 ms │ 17 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼─────────┼─────────┤ │ Req/Sec │ 25,871 │ 25,871 │ 26,719 │ 27,519 │ 26,608.54 │ 467.76 │ 25,856 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼─────────┼─────────┤ │ Bytes/Sec │ 70.8 MB │ 70.8 MB │ 73.1 MB │ 75.3 MB │ 72.8 MB │ 1.29 MB │ 70.8 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 2 │ ├────────────┼──────────────┤ │ 25 │ 3 │ ├────────────┼──────────────┤ │ 50 │ 3 │ ├────────────┼──────────────┤ │ 75 │ 4 │ ├────────────┼──────────────┤ │ 90 │ 4 │ ├────────────┼──────────────┤ │ 97.5 │ 5 │ ├────────────┼──────────────┤ │ 99 │ 5 │ ├────────────┼──────────────┤ │ 99.9 │ 7 │ ├────────────┼──────────────┤ │ 99.99 │ 12 │ ├────────────┼──────────────┤ │ 99.999 │ 16 │ └────────────┴──────────────┘ 399k requests in 15.01s, 1.09 GB read ``` **PostgreSQL** Requests / second 26,420 415,119 requests in 15 s Latency p50 3ms average 3.1 ms Latency p99 5ms max 14 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **27,674** · 2 : **25,166** req/s · spread 9.5 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.3 vCPU**, **116 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.0 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · Redis **0.2 vCPU** · whole server busy **95 %**, of which kernel (network, disk) **32 %** · memory used **1087 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get all with caching, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public_cached" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public_cached 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 3 ms │ 5 ms │ 5 ms │ 3.12 ms │ 0.84 ms │ 14 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬────────┬─────────┬───────────┬──────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼────────┼─────────┼───────────┼──────────┼─────────┤ │ Req/Sec │ 26,431 │ 26,431 │ 27,183 │ 29,935 │ 27,674.14 │ 1,244.91 │ 26,420 │ ├───────────┼─────────┼─────────┼────────┼─────────┼───────────┼──────────┼─────────┤ │ Bytes/Sec │ 64.1 MB │ 64.1 MB │ 66 MB │ 72.6 MB │ 67.1 MB │ 3.02 MB │ 64.1 MB │ └───────────┴─────────┴─────────┴────────┴─────────┴───────────┴──────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 1 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 2 │ ├────────────┼──────────────┤ │ 25 │ 3 │ ├────────────┼──────────────┤ │ 50 │ 3 │ ├────────────┼──────────────┤ │ 75 │ 4 │ ├────────────┼──────────────┤ │ 90 │ 4 │ ├────────────┼──────────────┤ │ 97.5 │ 5 │ ├────────────┼──────────────┤ │ 99 │ 5 │ ├────────────┼──────────────┤ │ 99.9 │ 6 │ ├────────────┼──────────────┤ │ 99.99 │ 11 │ ├────────────┼──────────────┤ │ 99.999 │ 13 │ └────────────┴──────────────┘ 415k requests in 15.01s, 1.01 GB read ``` **MySQL** Requests / second 25,630 382,667 requests in 15 s Latency p50 3ms average 3.4 ms Latency p99 6ms max 19 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **25,749** · 2 : **25,511** req/s · spread 0.9 % · the output below is round 2, the closer to the average (Server during this run) API Maker **3.4 vCPU**, **129 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.0 vCPU** · sandboxes **0.0 vCPU**, **518 MB** · Redis **0.2 vCPU** · whole server busy **95 %**, of which kernel (network, disk) **29 %** · memory used **2038 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get all with caching, public · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public_cached" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public_cached 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼────────┼───────┤ │ Latency │ 2 ms │ 3 ms │ 5 ms │ 6 ms │ 3.42 ms │ 0.9 ms │ 19 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼─────────┼─────────┤ │ Req/Sec │ 24,463 │ 24,463 │ 25,247 │ 27,663 │ 25,510.94 │ 908.48 │ 24,452 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼─────────┼─────────┤ │ Bytes/Sec │ 59.3 MB │ 59.3 MB │ 61.2 MB │ 67.1 MB │ 61.9 MB │ 2.21 MB │ 59.3 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 2 │ ├────────────┼──────────────┤ │ 25 │ 3 │ ├────────────┼──────────────┤ │ 50 │ 3 │ ├────────────┼──────────────┤ │ 75 │ 4 │ ├────────────┼──────────────┤ │ 90 │ 4 │ ├────────────┼──────────────┤ │ 97.5 │ 5 │ ├────────────┼──────────────┤ │ 99 │ 6 │ ├────────────┼──────────────┤ │ 99.9 │ 7 │ ├────────────┼──────────────┤ │ 99.99 │ 13 │ ├────────────┼──────────────┤ │ 99.999 │ 15 │ └────────────┴──────────────┘ 383k requests in 15.01s, 928 MB read ``` ### Get all with caching : both tokens With `x-am-authorization` and `x-am-user-authorization`, both checked on every request. Each answer : 2,418 bytes (MongoDB), status 200. **MongoDB** Requests / second 20,550 304,157 requests in 15 s Latency p50 4ms average 4.4 ms Latency p99 7ms max 20 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **20,277** · 2 : **20,823** req/s · spread 2.7 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.5 vCPU**, **121 MB** RSS · MongoDB **0.0 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · Redis **0.1 vCPU** · whole server busy **98 %**, of which kernel (network, disk) **27 %** · memory used **897 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get all with caching, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_cached" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_cached 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 4 ms │ 7 ms │ 7 ms │ 4.43 ms │ 1.09 ms │ 20 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 19,647 │ 19,647 │ 20,287 │ 21,135 │ 20,276.8 │ 352.55 │ 19,642 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 53.8 MB │ 53.8 MB │ 55.5 MB │ 57.9 MB │ 55.5 MB │ 970 kB │ 53.8 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 3 │ ├────────────┼──────────────┤ │ 25 │ 4 │ ├────────────┼──────────────┤ │ 50 │ 4 │ ├────────────┼──────────────┤ │ 75 │ 5 │ ├────────────┼──────────────┤ │ 90 │ 6 │ ├────────────┼──────────────┤ │ 97.5 │ 7 │ ├────────────┼──────────────┤ │ 99 │ 7 │ ├────────────┼──────────────┤ │ 99.9 │ 8 │ ├────────────┼──────────────┤ │ 99.99 │ 13 │ ├────────────┼──────────────┤ │ 99.999 │ 17 │ └────────────┴──────────────┘ 304k requests in 15.02s, 832 MB read ``` **PostgreSQL** Requests / second 20,113 305,142 requests in 15 s Latency p50 4ms average 4.4 ms Latency p99 8ms max 18 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **20,341** · 2 : **19,885** req/s · spread 2.3 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.5 vCPU**, **116 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.0 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · Redis **0.1 vCPU** · whole server busy **97 %**, of which kernel (network, disk) **26 %** · memory used **1087 MB** of 7942 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get all with caching, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_cached" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_cached 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼────────┼───────┤ │ Latency │ 2 ms │ 4 ms │ 7 ms │ 8 ms │ 4.42 ms │ 1.2 ms │ 18 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬──────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼──────────┼─────────┤ │ Req/Sec │ 16,623 │ 16,623 │ 20,351 │ 21,871 │ 20,340.8 │ 1,196.44 │ 16,617 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼──────────┼─────────┤ │ Bytes/Sec │ 40.3 MB │ 40.3 MB │ 49.4 MB │ 53.1 MB │ 49.4 MB │ 2.9 MB │ 40.3 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴──────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 3 │ ├────────────┼──────────────┤ │ 25 │ 4 │ ├────────────┼──────────────┤ │ 50 │ 4 │ ├────────────┼──────────────┤ │ 75 │ 5 │ ├────────────┼──────────────┤ │ 90 │ 6 │ ├────────────┼──────────────┤ │ 97.5 │ 7 │ ├────────────┼──────────────┤ │ 99 │ 8 │ ├────────────┼──────────────┤ │ 99.9 │ 12 │ ├────────────┼──────────────┤ │ 99.99 │ 15 │ ├────────────┼──────────────┤ │ 99.999 │ 17 │ └────────────┴──────────────┘ 305k requests in 15.01s, 740 MB read ``` **MySQL** Requests / second 20,763 322,649 requests in 15 s Latency p50 4ms average 4.2 ms Latency p99 7ms max 17 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **21,511** · 2 : **20,016** req/s · spread 7.2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.5 vCPU**, **119 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.0 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · Redis **0.2 vCPU** · whole server busy **97 %**, of which kernel (network, disk) **26 %** · memory used **1468 MB** of 7942 MB · steal **0 %** · swap not touched autocannon · MySQL · get all with caching, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_cached" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_cached 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 4 ms │ 6 ms │ 7 ms │ 4.15 ms │ 1.04 ms │ 17 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼────────┼─────────┤ │ Req/Sec │ 19,903 │ 19,903 │ 21,679 │ 22,143 │ 21,510.94 │ 534.75 │ 19,895 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼────────┼─────────┤ │ Bytes/Sec │ 48.3 MB │ 48.3 MB │ 52.6 MB │ 53.7 MB │ 52.2 MB │ 1.3 MB │ 48.3 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 3 │ ├────────────┼──────────────┤ │ 25 │ 3 │ ├────────────┼──────────────┤ │ 50 │ 4 │ ├────────────┼──────────────┤ │ 75 │ 5 │ ├────────────┼──────────────┤ │ 90 │ 5 │ ├────────────┼──────────────┤ │ 97.5 │ 6 │ ├────────────┼──────────────┤ │ 99 │ 7 │ ├────────────┼──────────────┤ │ 99.9 │ 8 │ ├────────────┼──────────────┤ │ 99.99 │ 13 │ ├────────────┼──────────────┤ │ 99.999 │ 17 │ └────────────┴──────────────┘ 323k requests in 15.01s, 783 MB read ``` ## Get all by stream `GET …/
/stream` : the rows are sent while they are read from the database cursor, so a large table never sits whole in memory. [About this API](https://docs.apimaker.dev/v4/docs/apis-all/schema-apis/auto-generated-schema-based-get-all-by-stream-api.html). ### Get all by stream : public No token : the API is public. Each answer : 2,477 bytes (MongoDB), status 200. **MongoDB** Requests / second 6,724 99,530 requests in 15 s Latency p50 14ms average 14.6 ms Latency p99 33ms max 76 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **6,636** · 2 : **6,812** req/s · spread 2.6 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.8 vCPU**, **128 MB** RSS · MongoDB **1.7 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **99 %**, of which kernel (network, disk) **29 %** · memory used **918 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get all by stream, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public/stream" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public/stream 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 6 ms │ 14 ms │ 27 ms │ 33 ms │ 14.57 ms │ 5.57 ms │ 76 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 6,459 │ 6,459 │ 6,655 │ 6,895 │ 6,635.87 │ 101.56 │ 6,457 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 18.6 MB │ 18.6 MB │ 19.2 MB │ 19.9 MB │ 19.1 MB │ 294 kB │ 18.6 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 5 │ ├────────────┼──────────────┤ │ 2.5 │ 6 │ ├────────────┼──────────────┤ │ 10 │ 9 │ ├────────────┼──────────────┤ │ 25 │ 11 │ ├────────────┼──────────────┤ │ 50 │ 14 │ ├────────────┼──────────────┤ │ 75 │ 17 │ ├────────────┼──────────────┤ │ 90 │ 21 │ ├────────────┼──────────────┤ │ 97.5 │ 27 │ ├────────────┼──────────────┤ │ 99 │ 33 │ ├────────────┼──────────────┤ │ 99.9 │ 53 │ ├────────────┼──────────────┤ │ 99.99 │ 64 │ ├────────────┼──────────────┤ │ 99.999 │ 76 │ └────────────┴──────────────┘ 100k requests in 15.02s, 287 MB read ``` **PostgreSQL** Requests / second 8,226 124,693 requests in 15 s Latency p50 12ms average 11.5 ms Latency p99 14ms max 24 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **8,313** · 2 : **8,138** req/s · spread 2.1 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.0 vCPU**, **130 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **1.0 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **91 %**, of which kernel (network, disk) **34 %** · memory used **1102 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get all by stream, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public/stream" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public/stream 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 10 ms │ 12 ms │ 13 ms │ 14 ms │ 11.53 ms │ 1.03 ms │ 24 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 8,035 │ 8,035 │ 8,319 │ 8,511 │ 8,313.21 │ 103.55 │ 8,032 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 20.7 MB │ 20.7 MB │ 21.4 MB │ 21.9 MB │ 21.4 MB │ 266 kB │ 20.7 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 10 │ ├────────────┼──────────────┤ │ 2.5 │ 10 │ ├────────────┼──────────────┤ │ 10 │ 11 │ ├────────────┼──────────────┤ │ 25 │ 11 │ ├────────────┼──────────────┤ │ 50 │ 12 │ ├────────────┼──────────────┤ │ 75 │ 12 │ ├────────────┼──────────────┤ │ 90 │ 13 │ ├────────────┼──────────────┤ │ 97.5 │ 13 │ ├────────────┼──────────────┤ │ 99 │ 14 │ ├────────────┼──────────────┤ │ 99.9 │ 15 │ ├────────────┼──────────────┤ │ 99.99 │ 21 │ ├────────────┼──────────────┤ │ 99.999 │ 23 │ └────────────┴──────────────┘ 125k requests in 15.01s, 321 MB read ``` **MySQL** Requests / second 8,355 120,464 requests in 15 s Latency p50 12ms average 11.9 ms Latency p99 14ms max 23 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **8,678** · 2 : **8,032** req/s · spread 7.7 % · the output below is round 2, the closer to the average (Server during this run) API Maker **2.2 vCPU**, **137 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.7 vCPU** · sandboxes **0.0 vCPU**, **518 MB** · whole server busy **91 %**, of which kernel (network, disk) **32 %** · memory used **2048 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get all by stream, public · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public/stream" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public/stream 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼────────┼───────┤ │ Latency │ 10 ms │ 12 ms │ 14 ms │ 14 ms │ 11.95 ms │ 1.1 ms │ 23 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 7,915 │ 7,915 │ 8,015 │ 8,263 │ 8,031.47 │ 89.27 │ 7,912 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 20.4 MB │ 20.4 MB │ 20.6 MB │ 21.3 MB │ 20.7 MB │ 230 kB │ 20.4 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 10 │ ├────────────┼──────────────┤ │ 2.5 │ 10 │ ├────────────┼──────────────┤ │ 10 │ 11 │ ├────────────┼──────────────┤ │ 25 │ 11 │ ├────────────┼──────────────┤ │ 50 │ 12 │ ├────────────┼──────────────┤ │ 75 │ 13 │ ├────────────┼──────────────┤ │ 90 │ 13 │ ├────────────┼──────────────┤ │ 97.5 │ 14 │ ├────────────┼──────────────┤ │ 99 │ 14 │ ├────────────┼──────────────┤ │ 99.9 │ 16 │ ├────────────┼──────────────┤ │ 99.99 │ 20 │ ├────────────┼──────────────┤ │ 99.999 │ 22 │ └────────────┴──────────────┘ 121k requests in 15.02s, 310 MB read ``` ### Get all by stream : both tokens With `x-am-authorization` and `x-am-user-authorization`, both checked on every request. Each answer : 2,577 bytes (MongoDB), status 200. **MongoDB** Requests / second 6,737 99,542 requests in 15 s Latency p50 14ms average 14.6 ms Latency p99 29ms max 64 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **6,838** · 2 : **6,637** req/s · spread 3 % · the output below is round 2, the closer to the average (Server during this run) API Maker **2.0 vCPU**, **135 MB** RSS · MongoDB **1.5 vCPU** · sandboxes **0.0 vCPU**, **582 MB** · whole server busy **99 %**, of which kernel (network, disk) **26 %** · memory used **1593 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get all by stream, both tokens · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers/stream" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers/stream 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 7 ms │ 14 ms │ 25 ms │ 29 ms │ 14.57 ms │ 4.73 ms │ 64 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 6,515 │ 6,515 │ 6,611 │ 6,823 │ 6,636.94 │ 85.48 │ 6,512 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 19.4 MB │ 19.4 MB │ 19.7 MB │ 20.4 MB │ 19.8 MB │ 257 kB │ 19.4 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 3 │ ├────────────┼──────────────┤ │ 1 │ 5 │ ├────────────┼──────────────┤ │ 2.5 │ 7 │ ├────────────┼──────────────┤ │ 10 │ 9 │ ├────────────┼──────────────┤ │ 25 │ 11 │ ├────────────┼──────────────┤ │ 50 │ 14 │ ├────────────┼──────────────┤ │ 75 │ 17 │ ├────────────┼──────────────┤ │ 90 │ 20 │ ├────────────┼──────────────┤ │ 97.5 │ 25 │ ├────────────┼──────────────┤ │ 99 │ 29 │ ├────────────┼──────────────┤ │ 99.9 │ 39 │ ├────────────┼──────────────┤ │ 99.99 │ 52 │ ├────────────┼──────────────┤ │ 99.999 │ 64 │ └────────────┴──────────────┘ 100k requests in 15.02s, 297 MB read ``` **PostgreSQL** Requests / second 7,486 113,375 requests in 15 s Latency p50 13ms average 12.7 ms Latency p99 15ms max 24 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **7,559** · 2 : **7,412** req/s · spread 2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.2 vCPU**, **129 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.9 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **93 %**, of which kernel (network, disk) **31 %** · memory used **1103 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get all by stream, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers/stream" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers/stream 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼────────┼───────┤ │ Latency │ 11 ms │ 13 ms │ 15 ms │ 15 ms │ 12.73 ms │ 1.1 ms │ 24 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 7,403 │ 7,403 │ 7,587 │ 7,675 │ 7,558.54 │ 82.88 │ 7,402 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 19.8 MB │ 19.8 MB │ 20.3 MB │ 20.5 MB │ 20.2 MB │ 222 kB │ 19.8 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 3 │ ├────────────┼──────────────┤ │ 1 │ 11 │ ├────────────┼──────────────┤ │ 2.5 │ 11 │ ├────────────┼──────────────┤ │ 10 │ 12 │ ├────────────┼──────────────┤ │ 25 │ 12 │ ├────────────┼──────────────┤ │ 50 │ 13 │ ├────────────┼──────────────┤ │ 75 │ 13 │ ├────────────┼──────────────┤ │ 90 │ 14 │ ├────────────┼──────────────┤ │ 97.5 │ 15 │ ├────────────┼──────────────┤ │ 99 │ 15 │ ├────────────┼──────────────┤ │ 99.9 │ 17 │ ├────────────┼──────────────┤ │ 99.99 │ 23 │ ├────────────┼──────────────┤ │ 99.999 │ 24 │ └────────────┴──────────────┘ 113k requests in 15.02s, 303 MB read ``` **MySQL** Requests / second 7,469 113,289 requests in 15 s Latency p50 13ms average 12.7 ms Latency p99 15ms max 24 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **7,553** · 2 : **7,386** req/s · spread 2.2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.4 vCPU**, **134 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.7 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **94 %**, of which kernel (network, disk) **32 %** · memory used **1482 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get all by stream, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers/stream" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers/stream 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 11 ms │ 13 ms │ 15 ms │ 15 ms │ 12.74 ms │ 1.11 ms │ 24 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬───────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼───────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 7,311 │ 7,311 │ 7,471 │ 8,035 │ 7,552.67 │ 214.25 │ 7,308 │ ├───────────┼─────────┼─────────┼───────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 19.5 MB │ 19.5 MB │ 20 MB │ 21.5 MB │ 20.2 MB │ 574 kB │ 19.5 MB │ └───────────┴─────────┴─────────┴───────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 11 │ ├────────────┼──────────────┤ │ 2.5 │ 11 │ ├────────────┼──────────────┤ │ 10 │ 12 │ ├────────────┼──────────────┤ │ 25 │ 12 │ ├────────────┼──────────────┤ │ 50 │ 13 │ ├────────────┼──────────────┤ │ 75 │ 13 │ ├────────────┼──────────────┤ │ 90 │ 14 │ ├────────────┼──────────────┤ │ 97.5 │ 15 │ ├────────────┼──────────────┤ │ 99 │ 15 │ ├────────────┼──────────────┤ │ 99.9 │ 17 │ ├────────────┼──────────────┤ │ 99.99 │ 22 │ ├────────────┼──────────────┤ │ 99.999 │ 24 │ └────────────┴──────────────┘ 113k requests in 15.01s, 303 MB read ``` ## Custom API calling get all A custom API written in TypeScript, `return await g.sys.db.getAll({ instance, database, collection })`. This code is *lean* : it only reads what it is handed and asks `g.sys` for a read, so API Maker runs it in the server itself, with QuickJS, on the thread which answers the request, and the request never leaves the server. Code which needs more (a package, the time of the machine, `g.shared`, …) runs in the sandbox of the account : see the next API. [About this API](https://docs.apimaker.dev/v4/docs/apis-all/custom-apis/user-created-custom-api.html). **The custom API (public : customers_public ; both tokens : customers)** ```typescript import * as T from 'types'; async function main(g: T.IAMGlobal) { return await g.sys.db.getAll({ instance: 'mongodb', database: 'am_bench', collection: 'customers_public' }); } module.exports = main; ``` ### Custom API calling get all : public No token : the API is public. Each answer : 2,418 bytes (MongoDB), status 200. **MongoDB** Requests / second 5,178 75,384 requests in 15 s Latency p50 19ms average 19.4 ms Latency p99 34ms max 54 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **5,330** · 2 : **5,026** req/s · spread 5.9 % · the output below is round 2, the closer to the average (Server during this run) API Maker **2.3 vCPU**, **132 MB** RSS · MongoDB **1.2 vCPU** · sandboxes **0.0 vCPU**, **582 MB** · whole server busy **99 %**, of which kernel (network, disk) **23 %** · memory used **1571 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · custom api calling get all, public · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/custom-api/bench/bench_mongodb_public" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_mongodb_public 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 9 ms │ 19 ms │ 31 ms │ 34 ms │ 19.39 ms │ 5.63 ms │ 54 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬───────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼───────┼──────────┼────────┼─────────┤ │ Req/Sec │ 4,935 │ 4,935 │ 5,027 │ 5,115 │ 5,026.27 │ 49.95 │ 4,933 │ ├───────────┼─────────┼─────────┼─────────┼───────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 13.5 MB │ 13.5 MB │ 13.7 MB │ 14 MB │ 13.7 MB │ 138 kB │ 13.5 MB │ └───────────┴─────────┴─────────┴─────────┴───────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 7 │ ├────────────┼──────────────┤ │ 2.5 │ 9 │ ├────────────┼──────────────┤ │ 10 │ 12 │ ├────────────┼──────────────┤ │ 25 │ 16 │ ├────────────┼──────────────┤ │ 50 │ 19 │ ├────────────┼──────────────┤ │ 75 │ 23 │ ├────────────┼──────────────┤ │ 90 │ 27 │ ├────────────┼──────────────┤ │ 97.5 │ 31 │ ├────────────┼──────────────┤ │ 99 │ 34 │ ├────────────┼──────────────┤ │ 99.9 │ 41 │ ├────────────┼──────────────┤ │ 99.99 │ 49 │ ├────────────┼──────────────┤ │ 99.999 │ 54 │ └────────────┴──────────────┘ 75k requests in 15.01s, 206 MB read ``` **PostgreSQL** Requests / second 5,658 85,337 requests in 15 s Latency p50 17ms average 17.1 ms Latency p99 20ms max 29 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **5,690** · 2 : **5,626** req/s · spread 1.1 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.7 vCPU**, **122 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.7 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **97 %**, of which kernel (network, disk) **25 %** · memory used **1099 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · custom api calling get all, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/custom-api/bench/bench_postgres_public" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_postgres_public 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼────────┼───────┤ │ Latency │ 15 ms │ 17 ms │ 19 ms │ 20 ms │ 17.07 ms │ 1.2 ms │ 29 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬───────┬──────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼───────┼──────────┼─────────┼─────────┤ │ Req/Sec │ 5,619 │ 5,619 │ 5,695 │ 5,763 │ 5,689.74 │ 40.89 │ 5,618 │ ├───────────┼─────────┼─────────┼─────────┼───────┼──────────┼─────────┼─────────┤ │ Bytes/Sec │ 13.6 MB │ 13.6 MB │ 13.8 MB │ 14 MB │ 13.8 MB │ 98.9 kB │ 13.6 MB │ └───────────┴─────────┴─────────┴─────────┴───────┴──────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 2 │ ├────────────┼──────────────┤ │ 0.1 │ 8 │ ├────────────┼──────────────┤ │ 1 │ 15 │ ├────────────┼──────────────┤ │ 2.5 │ 15 │ ├────────────┼──────────────┤ │ 10 │ 16 │ ├────────────┼──────────────┤ │ 25 │ 16 │ ├────────────┼──────────────┤ │ 50 │ 17 │ ├────────────┼──────────────┤ │ 75 │ 18 │ ├────────────┼──────────────┤ │ 90 │ 18 │ ├────────────┼──────────────┤ │ 97.5 │ 19 │ ├────────────┼──────────────┤ │ 99 │ 20 │ ├────────────┼──────────────┤ │ 99.9 │ 22 │ ├────────────┼──────────────┤ │ 99.99 │ 26 │ ├────────────┼──────────────┤ │ 99.999 │ 29 │ └────────────┴──────────────┘ 85k requests in 15.02s, 207 MB read ``` **MySQL** Requests / second 6,016 90,945 requests in 15 s Latency p50 16ms average 16.0 ms Latency p99 19ms max 27 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **6,063** · 2 : **5,968** req/s · spread 1.6 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.7 vCPU**, **127 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.6 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **97 %**, of which kernel (network, disk) **26 %** · memory used **1478 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · custom api calling get all, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/custom-api/bench/bench_mysql_public" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_mysql_public 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 14 ms │ 16 ms │ 18 ms │ 19 ms │ 15.99 ms │ 1.24 ms │ 27 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 5,939 │ 5,939 │ 6,067 │ 6,155 │ 6,063.34 │ 56.19 │ 5,938 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 14.4 MB │ 14.4 MB │ 14.7 MB │ 14.9 MB │ 14.7 MB │ 136 kB │ 14.4 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 14 │ ├────────────┼──────────────┤ │ 2.5 │ 14 │ ├────────────┼──────────────┤ │ 10 │ 15 │ ├────────────┼──────────────┤ │ 25 │ 15 │ ├────────────┼──────────────┤ │ 50 │ 16 │ ├────────────┼──────────────┤ │ 75 │ 17 │ ├────────────┼──────────────┤ │ 90 │ 17 │ ├────────────┼──────────────┤ │ 97.5 │ 18 │ ├────────────┼──────────────┤ │ 99 │ 19 │ ├────────────┼──────────────┤ │ 99.9 │ 20 │ ├────────────┼──────────────┤ │ 99.99 │ 24 │ ├────────────┼──────────────┤ │ 99.999 │ 27 │ └────────────┴──────────────┘ 91k requests in 15.02s, 220 MB read ``` ### Custom API calling get all : both tokens With `x-am-authorization` and `x-am-user-authorization`, both checked on every request. Each answer : 2,418 bytes (MongoDB), status 200. **MongoDB** Requests / second 4,910 74,827 requests in 15 s Latency p50 19ms average 19.5 ms Latency p99 34ms max 50 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **4,989** · 2 : **4,831** req/s · spread 3.2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.5 vCPU**, **130 MB** RSS · MongoDB **1.1 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **99 %**, of which kernel (network, disk) **21 %** · memory used **946 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · custom api calling get all, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/custom-api/bench/bench_mongodb_tokens" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_mongodb_tokens 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 9 ms │ 19 ms │ 32 ms │ 34 ms │ 19.54 ms │ 5.75 ms │ 50 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬───────┬───────┬─────────┬─────────┬─────────┬────────┬───────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼───────┼───────┼─────────┼─────────┼─────────┼────────┼───────┤ │ Req/Sec │ 4,755 │ 4,755 │ 4,859 │ 5,407 │ 4,989.2 │ 221.79 │ 4,755 │ ├───────────┼───────┼───────┼─────────┼─────────┼─────────┼────────┼───────┤ │ Bytes/Sec │ 13 MB │ 13 MB │ 13.3 MB │ 14.8 MB │ 13.6 MB │ 606 kB │ 13 MB │ └───────────┴───────┴───────┴─────────┴─────────┴─────────┴────────┴───────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 3 │ ├────────────┼──────────────┤ │ 1 │ 7 │ ├────────────┼──────────────┤ │ 2.5 │ 9 │ ├────────────┼──────────────┤ │ 10 │ 12 │ ├────────────┼──────────────┤ │ 25 │ 16 │ ├────────────┼──────────────┤ │ 50 │ 19 │ ├────────────┼──────────────┤ │ 75 │ 23 │ ├────────────┼──────────────┤ │ 90 │ 27 │ ├────────────┼──────────────┤ │ 97.5 │ 32 │ ├────────────┼──────────────┤ │ 99 │ 34 │ ├────────────┼──────────────┤ │ 99.9 │ 40 │ ├────────────┼──────────────┤ │ 99.99 │ 48 │ ├────────────┼──────────────┤ │ 99.999 │ 50 │ └────────────┴──────────────┘ 75k requests in 15.02s, 205 MB read ``` **PostgreSQL** Requests / second 5,158 77,441 requests in 15 s Latency p50 19ms average 18.9 ms Latency p99 22ms max 30 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **5,163** · 2 : **5,153** req/s · spread 0.2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.8 vCPU**, **123 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.6 vCPU** · sandboxes **0.0 vCPU**, **55 MB** · whole server busy **96 %**, of which kernel (network, disk) **23 %** · memory used **1100 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · custom api calling get all, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/custom-api/bench/bench_postgres_tokens" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_postgres_tokens 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 17 ms │ 19 ms │ 22 ms │ 22 ms │ 18.87 ms │ 1.54 ms │ 30 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 5,075 │ 5,075 │ 5,183 │ 5,239 │ 5,163.34 │ 53.02 │ 5,074 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 12.3 MB │ 12.3 MB │ 12.6 MB │ 12.7 MB │ 12.5 MB │ 129 kB │ 12.3 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 3 │ ├────────────┼──────────────┤ │ 1 │ 16 │ ├────────────┼──────────────┤ │ 2.5 │ 17 │ ├────────────┼──────────────┤ │ 10 │ 17 │ ├────────────┼──────────────┤ │ 25 │ 18 │ ├────────────┼──────────────┤ │ 50 │ 19 │ ├────────────┼──────────────┤ │ 75 │ 20 │ ├────────────┼──────────────┤ │ 90 │ 20 │ ├────────────┼──────────────┤ │ 97.5 │ 22 │ ├────────────┼──────────────┤ │ 99 │ 22 │ ├────────────┼──────────────┤ │ 99.9 │ 24 │ ├────────────┼──────────────┤ │ 99.99 │ 28 │ ├────────────┼──────────────┤ │ 99.999 │ 30 │ └────────────┴──────────────┘ 78k requests in 15.01s, 188 MB read ``` **MySQL** Requests / second 5,536 83,494 requests in 15 s Latency p50 17ms average 17.5 ms Latency p99 20ms max 26 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **5,504** · 2 : **5,567** req/s · spread 1.1 % · the output below is round 2, the closer to the average (Server during this run) API Maker **2.9 vCPU**, **131 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.6 vCPU** · sandboxes **0.0 vCPU**, **518 MB** · whole server busy **98 %**, of which kernel (network, disk) **24 %** · memory used **2025 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · custom api calling get all, both tokens · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/custom-api/bench/bench_mysql_tokens" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_mysql_tokens 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 16 ms │ 17 ms │ 20 ms │ 20 ms │ 17.46 ms │ 1.34 ms │ 26 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤ │ Req/Sec │ 5,451 │ 5,451 │ 5,571 │ 5,663 │ 5,566.8 │ 59.1 │ 5,450 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤ │ Bytes/Sec │ 13.2 MB │ 13.2 MB │ 13.5 MB │ 13.7 MB │ 13.5 MB │ 143 kB │ 13.2 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 15 │ ├────────────┼──────────────┤ │ 2.5 │ 16 │ ├────────────┼──────────────┤ │ 10 │ 16 │ ├────────────┼──────────────┤ │ 25 │ 17 │ ├────────────┼──────────────┤ │ 50 │ 17 │ ├────────────┼──────────────┤ │ 75 │ 18 │ ├────────────┼──────────────┤ │ 90 │ 19 │ ├────────────┼──────────────┤ │ 97.5 │ 20 │ ├────────────┼──────────────┤ │ 99 │ 20 │ ├────────────┼──────────────┤ │ 99.9 │ 23 │ ├────────────┼──────────────┤ │ 99.99 │ 25 │ ├────────────┼──────────────┤ │ 99.999 │ 26 │ └────────────┴──────────────┘ 84k requests in 15.02s, 202 MB read ``` ## Custom API in the sandbox The same custom API, with one line more : it reads `Date.now()`, the time of the machine, which lean code may not. So this code runs in a sandbox of the account (a container with Node.js 24) : the request goes from API Maker to a runner of the sandbox and back, and the rows are read from inside the sandbox by the core of API Maker loaded there. [About this API](https://docs.apimaker.dev/v4/docs/apis-all/custom-apis/user-created-custom-api.html). **The custom API which runs in the sandbox** ```typescript import * as T from 'types'; async function main(g: T.IAMGlobal) { const started = Date.now(); // the time of the machine : this code runs in the sandbox of the account return await g.sys.db.getAll({ instance: 'mongodb', database: 'am_bench', collection: 'customers_public' }); } module.exports = main; ``` No token : the API is public. Each answer : 2,418 bytes (MongoDB), status 200. **MongoDB** Requests / second 4,649 69,667 requests in 15 s Latency p50 20ms average 21.0 ms Latency p99 42ms max 112 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **4,645** · 2 : **4,653** req/s · spread 0.2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.0 vCPU**, **125 MB** RSS · MongoDB **1.1 vCPU** · sandboxes **1.8 vCPU**, **577 MB** · whole server busy **100 %**, of which kernel (network, disk) **21 %** · memory used **1465 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · custom api in the sandbox, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/custom-api/bench/bench_mongodb_sandbox" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_mongodb_sandbox 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬────────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼────────┤ │ Latency │ 9 ms │ 20 ms │ 38 ms │ 42 ms │ 21.02 ms │ 7.81 ms │ 112 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴────────┘ ┌───────────┬─────────┬─────────┬─────────┬───────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼───────┼──────────┼────────┼─────────┤ │ Req/Sec │ 4,499 │ 4,499 │ 4,667 │ 4,751 │ 4,644.94 │ 67.42 │ 4,496 │ ├───────────┼─────────┼─────────┼─────────┼───────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 12.3 MB │ 12.3 MB │ 12.8 MB │ 13 MB │ 12.7 MB │ 185 kB │ 12.3 MB │ └───────────┴─────────┴─────────┴─────────┴───────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 2 │ ├────────────┼──────────────┤ │ 0.01 │ 2 │ ├────────────┼──────────────┤ │ 0.1 │ 4 │ ├────────────┼──────────────┤ │ 1 │ 7 │ ├────────────┼──────────────┤ │ 2.5 │ 9 │ ├────────────┼──────────────┤ │ 10 │ 12 │ ├────────────┼──────────────┤ │ 25 │ 15 │ ├────────────┼──────────────┤ │ 50 │ 20 │ ├────────────┼──────────────┤ │ 75 │ 26 │ ├────────────┼──────────────┤ │ 90 │ 31 │ ├────────────┼──────────────┤ │ 97.5 │ 38 │ ├────────────┼──────────────┤ │ 99 │ 42 │ ├────────────┼──────────────┤ │ 99.9 │ 65 │ ├────────────┼──────────────┤ │ 99.99 │ 93 │ ├────────────┼──────────────┤ │ 99.999 │ 112 │ └────────────┴──────────────┘ 70k requests in 15.02s, 191 MB read ``` **PostgreSQL** Requests / second 5,126 77,048 requests in 15 s Latency p50 19ms average 19.0 ms Latency p99 35ms max 52 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **5,137** · 2 : **5,115** req/s · spread 0.4 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.1 vCPU**, **120 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.7 vCPU** · sandboxes **1.7 vCPU**, **538 MB** · whole server busy **99 %**, of which kernel (network, disk) **25 %** · memory used **1730 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · custom api in the sandbox, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/custom-api/bench/bench_postgres_sandbox" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_postgres_sandbox 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 8 ms │ 19 ms │ 32 ms │ 35 ms │ 18.97 ms │ 6.42 ms │ 52 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 5,023 │ 5,023 │ 5,123 │ 5,287 │ 5,136.94 │ 74.19 │ 5,020 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 12.2 MB │ 12.2 MB │ 12.4 MB │ 12.8 MB │ 12.5 MB │ 181 kB │ 12.2 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 2 │ ├────────────┼──────────────┤ │ 0.01 │ 2 │ ├────────────┼──────────────┤ │ 0.1 │ 4 │ ├────────────┼──────────────┤ │ 1 │ 7 │ ├────────────┼──────────────┤ │ 2.5 │ 8 │ ├────────────┼──────────────┤ │ 10 │ 11 │ ├────────────┼──────────────┤ │ 25 │ 14 │ ├────────────┼──────────────┤ │ 50 │ 19 │ ├────────────┼──────────────┤ │ 75 │ 23 │ ├────────────┼──────────────┤ │ 90 │ 27 │ ├────────────┼──────────────┤ │ 97.5 │ 32 │ ├────────────┼──────────────┤ │ 99 │ 35 │ ├────────────┼──────────────┤ │ 99.9 │ 44 │ ├────────────┼──────────────┤ │ 99.99 │ 50 │ ├────────────┼──────────────┤ │ 99.999 │ 52 │ └────────────┴──────────────┘ 77k requests in 15.02s, 187 MB read ``` **MySQL** Requests / second 5,486 82,434 requests in 15 s Latency p50 17ms average 17.7 ms Latency p99 33ms max 53 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **5,496** · 2 : **5,475** req/s · spread 0.4 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.2 vCPU**, **125 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.6 vCPU** · sandboxes **1.7 vCPU**, **503 MB** · whole server busy **99 %**, of which kernel (network, disk) **27 %** · memory used **1991 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · custom api in the sandbox, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/custom-api/bench/bench_mysql_sandbox" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_mysql_sandbox 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 7 ms │ 17 ms │ 30 ms │ 33 ms │ 17.69 ms │ 6.01 ms │ 53 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 5,335 │ 5,335 │ 5,519 │ 5,619 │ 5,496.14 │ 78.93 │ 5,335 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 12.9 MB │ 12.9 MB │ 13.4 MB │ 13.6 MB │ 13.3 MB │ 192 kB │ 12.9 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 2 │ ├────────────┼──────────────┤ │ 0.01 │ 2 │ ├────────────┼──────────────┤ │ 0.1 │ 4 │ ├────────────┼──────────────┤ │ 1 │ 6 │ ├────────────┼──────────────┤ │ 2.5 │ 7 │ ├────────────┼──────────────┤ │ 10 │ 10 │ ├────────────┼──────────────┤ │ 25 │ 13 │ ├────────────┼──────────────┤ │ 50 │ 17 │ ├────────────┼──────────────┤ │ 75 │ 22 │ ├────────────┼──────────────┤ │ 90 │ 26 │ ├────────────┼──────────────┤ │ 97.5 │ 30 │ ├────────────┼──────────────┤ │ 99 │ 33 │ ├────────────┼──────────────┤ │ 99.9 │ 39 │ ├────────────┼──────────────┤ │ 99.99 │ 46 │ ├────────────┼──────────────┤ │ 99.999 │ 53 │ └────────────┴──────────────┘ 83k requests in 15.01s, 200 MB read ``` ## Get all with a pre hook Get all, with both tokens, on a table whose get all API has a pre hook written in TypeScript : before the API, the hook runs (lean code : in the server, with QuickJS), reads the signed-in person from `x-am-user-authorization` and keeps the rows of their country (`g.req.query.find`), the row scoping most applications need. Every row of the dataset is in India, as the person is, so the answer is the same ten rows. [About this API](https://docs.apimaker.dev/v4/docs/apis-all/hooks/preHook-api.html). **The pre hook of SCHEMA_GET_ALL on customers_pre_hook** ```typescript import * as T from 'types'; async function main(g: T.IAMGlobal) { if (!g.req.isApiRequestFromUser) return; const person = g.req.auth.authAMDB; // the person, from x-am-user-authorization if (!person) throw [{ code: T.EStatusCode.UNAUTHORIZED, message: 'Sign in first.' }]; const find = g.req.query.find ? (typeof g.req.query.find === 'string' ? JSON.parse(g.req.query.find) : g.req.query.find) : {}; g.req.query.find = { $and: [find, { country: person.country }] }; } module.exports = main; ``` With `x-am-authorization` and `x-am-user-authorization`, both checked on every request. Each answer : 2,418 bytes (MongoDB), status 200. **MongoDB** Requests / second 5,327 80,031 requests in 15 s Latency p50 18ms average 18.2 ms Latency p99 34ms max 66 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **5,336** · 2 : **5,318** req/s · spread 0.3 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.1 vCPU**, **128 MB** RSS · MongoDB **1.4 vCPU** · sandboxes **0.0 vCPU**, **601 MB** · whole server busy **99 %**, of which kernel (network, disk) **24 %** · memory used **1507 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get all with a pre hook, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_pre_hook" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_pre_hook 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 9 ms │ 18 ms │ 30 ms │ 34 ms │ 18.24 ms │ 5.58 ms │ 66 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 5,151 │ 5,151 │ 5,251 │ 5,715 │ 5,336.14 │ 171.74 │ 5,150 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 14.1 MB │ 14.1 MB │ 14.4 MB │ 15.6 MB │ 14.6 MB │ 471 kB │ 14.1 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 2 │ ├────────────┼──────────────┤ │ 0.1 │ 3 │ ├────────────┼──────────────┤ │ 1 │ 7 │ ├────────────┼──────────────┤ │ 2.5 │ 9 │ ├────────────┼──────────────┤ │ 10 │ 12 │ ├────────────┼──────────────┤ │ 25 │ 14 │ ├────────────┼──────────────┤ │ 50 │ 18 │ ├────────────┼──────────────┤ │ 75 │ 22 │ ├────────────┼──────────────┤ │ 90 │ 25 │ ├────────────┼──────────────┤ │ 97.5 │ 30 │ ├────────────┼──────────────┤ │ 99 │ 34 │ ├────────────┼──────────────┤ │ 99.9 │ 45 │ ├────────────┼──────────────┤ │ 99.99 │ 58 │ ├────────────┼──────────────┤ │ 99.999 │ 66 │ └────────────┴──────────────┘ 80k requests in 15.01s, 219 MB read ``` **PostgreSQL** Requests / second 6,151 93,295 requests in 15 s Latency p50 16ms average 15.6 ms Latency p99 18ms max 25 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **6,220** · 2 : **6,082** req/s · spread 2.3 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.4 vCPU**, **121 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.8 vCPU** · sandboxes **0.0 vCPU**, **545 MB** · whole server busy **95 %**, of which kernel (network, disk) **27 %** · memory used **1737 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get all with a pre hook, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_pre_hook" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_pre_hook 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 14 ms │ 16 ms │ 18 ms │ 18 ms │ 15.58 ms │ 1.33 ms │ 25 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 6,103 │ 6,103 │ 6,231 │ 6,335 │ 6,220.14 │ 66.15 │ 6,100 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 14.8 MB │ 14.8 MB │ 15.1 MB │ 15.4 MB │ 15.1 MB │ 161 kB │ 14.8 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 13 │ ├────────────┼──────────────┤ │ 2.5 │ 14 │ ├────────────┼──────────────┤ │ 10 │ 14 │ ├────────────┼──────────────┤ │ 25 │ 15 │ ├────────────┼──────────────┤ │ 50 │ 16 │ ├────────────┼──────────────┤ │ 75 │ 16 │ ├────────────┼──────────────┤ │ 90 │ 17 │ ├────────────┼──────────────┤ │ 97.5 │ 18 │ ├────────────┼──────────────┤ │ 99 │ 18 │ ├────────────┼──────────────┤ │ 99.9 │ 20 │ ├────────────┼──────────────┤ │ 99.99 │ 23 │ ├────────────┼──────────────┤ │ 99.999 │ 25 │ └────────────┴──────────────┘ 93k requests in 15.02s, 226 MB read ``` **MySQL** Requests / second 6,768 104,649 requests in 15 s Latency p50 14ms average 13.8 ms Latency p99 17ms max 29 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **6,977** · 2 : **6,559** req/s · spread 6.2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.5 vCPU**, **126 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.7 vCPU** · sandboxes **0.0 vCPU**, **503 MB** · whole server busy **95 %**, of which kernel (network, disk) **27 %** · memory used **1985 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get all with a pre hook, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_pre_hook" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_pre_hook 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼────────┼───────┤ │ Latency │ 12 ms │ 14 ms │ 16 ms │ 17 ms │ 13.83 ms │ 1.2 ms │ 29 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬───────┬─────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼───────┼─────────┼────────┼─────────┤ │ Req/Sec │ 6,783 │ 6,783 │ 6,887 │ 7,415 │ 6,977.2 │ 189.32 │ 6,783 │ ├───────────┼─────────┼─────────┼─────────┼───────┼─────────┼────────┼─────────┤ │ Bytes/Sec │ 16.4 MB │ 16.4 MB │ 16.7 MB │ 18 MB │ 16.9 MB │ 460 kB │ 16.4 MB │ └───────────┴─────────┴─────────┴─────────┴───────┴─────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 2 │ ├────────────┼──────────────┤ │ 0.01 │ 2 │ ├────────────┼──────────────┤ │ 0.1 │ 6 │ ├────────────┼──────────────┤ │ 1 │ 12 │ ├────────────┼──────────────┤ │ 2.5 │ 12 │ ├────────────┼──────────────┤ │ 10 │ 13 │ ├────────────┼──────────────┤ │ 25 │ 13 │ ├────────────┼──────────────┤ │ 50 │ 14 │ ├────────────┼──────────────┤ │ 75 │ 14 │ ├────────────┼──────────────┤ │ 90 │ 15 │ ├────────────┼──────────────┤ │ 97.5 │ 16 │ ├────────────┼──────────────┤ │ 99 │ 17 │ ├────────────┼──────────────┤ │ 99.9 │ 20 │ ├────────────┼──────────────┤ │ 99.99 │ 26 │ ├────────────┼──────────────┤ │ 99.999 │ 28 │ └────────────┴──────────────┘ 105k requests in 15.01s, 254 MB read ``` ## Get by id One row by its primary key : `GET …/
/get-by-id/`. [About this API](https://docs.apimaker.dev/v4/docs/apis-all/schema-apis/auto-generated-schema-based-get-by-id-api.html). ### Get by id : public No token : the API is public. Each answer : 278 bytes (MongoDB), status 200. **MongoDB** Requests / second 8,076 120,738 requests in 15 s Latency p50 11ms average 11.9 ms Latency p99 26ms max 79 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **8,104** · 2 : **8,049** req/s · spread 0.7 % · the output below is round 2, the closer to the average (Server during this run) API Maker **1.8 vCPU**, **131 MB** RSS · MongoDB **1.6 vCPU** · sandboxes **0.0 vCPU**, **477 MB** · whole server busy **99 %**, of which kernel (network, disk) **30 %** · memory used **1456 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get by id, public · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public/get-by-id/60ae2488c37cd955cc144161" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public/get-by-id/60ae2488c37cd955cc144161 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 5 ms │ 11 ms │ 22 ms │ 26 ms │ 11.92 ms │ 4.38 ms │ 79 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤ │ Req/Sec │ 7,523 │ 7,523 │ 8,163 │ 8,599 │ 8,049.2 │ 272.58 │ 7,522 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼────────┼─────────┤ │ Bytes/Sec │ 4.47 MB │ 4.47 MB │ 4.85 MB │ 5.11 MB │ 4.78 MB │ 162 kB │ 4.47 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 1 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 4 │ ├────────────┼──────────────┤ │ 2.5 │ 5 │ ├────────────┼──────────────┤ │ 10 │ 7 │ ├────────────┼──────────────┤ │ 25 │ 9 │ ├────────────┼──────────────┤ │ 50 │ 11 │ ├────────────┼──────────────┤ │ 75 │ 14 │ ├────────────┼──────────────┤ │ 90 │ 17 │ ├────────────┼──────────────┤ │ 97.5 │ 22 │ ├────────────┼──────────────┤ │ 99 │ 26 │ ├────────────┼──────────────┤ │ 99.9 │ 40 │ ├────────────┼──────────────┤ │ 99.99 │ 51 │ ├────────────┼──────────────┤ │ 99.999 │ 77 │ └────────────┴──────────────┘ 121k requests in 15.01s, 71.7 MB read ``` **PostgreSQL** Requests / second 9,446 145,024 requests in 15 s Latency p50 10ms average 9.8 ms Latency p99 12ms max 22 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **9,669** · 2 : **9,222** req/s · spread 4.7 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.8 vCPU**, **122 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **1.1 vCPU** · sandboxes **0.0 vCPU**, **545 MB** · whole server busy **90 %**, of which kernel (network, disk) **35 %** · memory used **1728 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get by id, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public/get-by-id/2" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public/get-by-id/2 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼─────────┼─────────┼───────┤ │ Latency │ 9 ms │ 10 ms │ 12 ms │ 12 ms │ 9.84 ms │ 0.99 ms │ 22 ms │ └─────────┴──────┴───────┴───────┴───────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 9,167 │ 9,167 │ 9,863 │ 10,223 │ 9,669.07 │ 331.94 │ 9,167 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 5.14 MB │ 5.14 MB │ 5.53 MB │ 5.73 MB │ 5.42 MB │ 186 kB │ 5.14 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 8 │ ├────────────┼──────────────┤ │ 2.5 │ 9 │ ├────────────┼──────────────┤ │ 10 │ 9 │ ├────────────┼──────────────┤ │ 25 │ 9 │ ├────────────┼──────────────┤ │ 50 │ 10 │ ├────────────┼──────────────┤ │ 75 │ 10 │ ├────────────┼──────────────┤ │ 90 │ 11 │ ├────────────┼──────────────┤ │ 97.5 │ 12 │ ├────────────┼──────────────┤ │ 99 │ 12 │ ├────────────┼──────────────┤ │ 99.9 │ 14 │ ├────────────┼──────────────┤ │ 99.99 │ 17 │ ├────────────┼──────────────┤ │ 99.999 │ 21 │ └────────────┴──────────────┘ 145k requests in 15.02s, 81.4 MB read ``` **MySQL** Requests / second 9,893 153,601 requests in 15 s Latency p50 9ms average 9.3 ms Latency p99 11ms max 20 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **10,240** · 2 : **9,545** req/s · spread 7 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.0 vCPU**, **127 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.9 vCPU** · sandboxes **0.0 vCPU**, **502 MB** · whole server busy **90 %**, of which kernel (network, disk) **35 %** · memory used **1982 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get by id, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public/get-by-id/2" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public/get-by-id/2 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬───────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼───────┼─────────┼─────────┼───────┤ │ Latency │ 8 ms │ 9 ms │ 11 ms │ 11 ms │ 9.27 ms │ 0.86 ms │ 20 ms │ └─────────┴──────┴──────┴───────┴───────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼─────────┼─────────┤ │ Req/Sec │ 10,079 │ 10,079 │ 10,263 │ 10,407 │ 10,239.74 │ 81.37 │ 10,075 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼─────────┼─────────┤ │ Bytes/Sec │ 5.65 MB │ 5.65 MB │ 5.76 MB │ 5.84 MB │ 5.75 MB │ 46.4 kB │ 5.65 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 8 │ ├────────────┼──────────────┤ │ 2.5 │ 8 │ ├────────────┼──────────────┤ │ 10 │ 8 │ ├────────────┼──────────────┤ │ 25 │ 9 │ ├────────────┼──────────────┤ │ 50 │ 9 │ ├────────────┼──────────────┤ │ 75 │ 10 │ ├────────────┼──────────────┤ │ 90 │ 10 │ ├────────────┼──────────────┤ │ 97.5 │ 11 │ ├────────────┼──────────────┤ │ 99 │ 11 │ ├────────────┼──────────────┤ │ 99.9 │ 12 │ ├────────────┼──────────────┤ │ 99.99 │ 18 │ ├────────────┼──────────────┤ │ 99.999 │ 20 │ └────────────┴──────────────┘ 154k requests in 15.01s, 86.2 MB read ``` ### Get by id : both tokens With `x-am-authorization` and `x-am-user-authorization`, both checked on every request. Each answer : 278 bytes (MongoDB), status 200. **MongoDB** Requests / second 7,513 114,593 requests in 15 s Latency p50 12ms average 12.6 ms Latency p99 23ms max 46 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **7,640** · 2 : **7,386** req/s · spread 3.4 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.1 vCPU**, **130 MB** RSS · MongoDB **1.3 vCPU** · sandboxes **0.0 vCPU**, **477 MB** · whole server busy **99 %**, of which kernel (network, disk) **28 %** · memory used **1378 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get by id, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers/get-by-id/60ae2488c37cd955cc144161" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers/get-by-id/60ae2488c37cd955cc144161 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 6 ms │ 12 ms │ 21 ms │ 23 ms │ 12.59 ms │ 3.95 ms │ 46 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤ │ Req/Sec │ 7,455 │ 7,455 │ 7,635 │ 7,811 │ 7,640.14 │ 97.01 │ 7,454 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤ │ Bytes/Sec │ 4.43 MB │ 4.43 MB │ 4.53 MB │ 4.64 MB │ 4.54 MB │ 57.7 kB │ 4.43 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 5 │ ├────────────┼──────────────┤ │ 2.5 │ 6 │ ├────────────┼──────────────┤ │ 10 │ 8 │ ├────────────┼──────────────┤ │ 25 │ 10 │ ├────────────┼──────────────┤ │ 50 │ 12 │ ├────────────┼──────────────┤ │ 75 │ 15 │ ├────────────┼──────────────┤ │ 90 │ 18 │ ├────────────┼──────────────┤ │ 97.5 │ 21 │ ├────────────┼──────────────┤ │ 99 │ 23 │ ├────────────┼──────────────┤ │ 99.9 │ 32 │ ├────────────┼──────────────┤ │ 99.99 │ 41 │ ├────────────┼──────────────┤ │ 99.999 │ 45 │ └────────────┴──────────────┘ 115k requests in 15.01s, 68.1 MB read ``` **PostgreSQL** Requests / second 8,233 123,892 requests in 15 s Latency p50 11ms average 11.6 ms Latency p99 17ms max 25 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **8,260** · 2 : **8,206** req/s · spread 0.7 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.9 vCPU**, **122 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **1.0 vCPU** · sandboxes **0.0 vCPU**, **445 MB** · whole server busy **92 %**, of which kernel (network, disk) **33 %** · memory used **1643 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get by id, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers/get-by-id/2" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers/get-by-id/2 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼────────┼───────┤ │ Latency │ 10 ms │ 11 ms │ 15 ms │ 17 ms │ 11.61 ms │ 1.4 ms │ 25 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 6,731 │ 6,731 │ 8,263 │ 8,815 │ 8,260.27 │ 470.44 │ 6,731 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 3.78 MB │ 3.78 MB │ 4.63 MB │ 4.95 MB │ 4.63 MB │ 264 kB │ 3.78 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 1 │ ├────────────┼──────────────┤ │ 0.1 │ 2 │ ├────────────┼──────────────┤ │ 1 │ 9 │ ├────────────┼──────────────┤ │ 2.5 │ 10 │ ├────────────┼──────────────┤ │ 10 │ 10 │ ├────────────┼──────────────┤ │ 25 │ 11 │ ├────────────┼──────────────┤ │ 50 │ 11 │ ├────────────┼──────────────┤ │ 75 │ 12 │ ├────────────┼──────────────┤ │ 90 │ 13 │ ├────────────┼──────────────┤ │ 97.5 │ 15 │ ├────────────┼──────────────┤ │ 99 │ 17 │ ├────────────┼──────────────┤ │ 99.9 │ 21 │ ├────────────┼──────────────┤ │ 99.99 │ 23 │ ├────────────┼──────────────┤ │ 99.999 │ 25 │ └────────────┴──────────────┘ 124k requests in 15.02s, 69.5 MB read ``` **MySQL** Requests / second 8,892 137,132 requests in 15 s Latency p50 10ms average 10.4 ms Latency p99 13ms max 24 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **9,142** · 2 : **8,641** req/s · spread 5.6 % · the output below is round 1, the closer to the average (Server during this run) API Maker **2.2 vCPU**, **127 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.8 vCPU** · sandboxes **0.0 vCPU**, **502 MB** · whole server busy **92 %**, of which kernel (network, disk) **33 %** · memory used **1982 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get by id, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers/get-by-id/2" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers/get-by-id/2 100 connections 10 workers ┌─────────┬──────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 9 ms │ 10 ms │ 12 ms │ 13 ms │ 10.44 ms │ 0.95 ms │ 24 ms │ └─────────┴──────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬────────┬──────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼────────┼──────────┼─────────┼─────────┤ │ Req/Sec │ 8,951 │ 8,951 │ 9,167 │ 9,271 │ 9,142.14 │ 91.01 │ 8,946 │ ├───────────┼─────────┼─────────┼─────────┼────────┼──────────┼─────────┼─────────┤ │ Bytes/Sec │ 5.02 MB │ 5.02 MB │ 5.14 MB │ 5.2 MB │ 5.13 MB │ 50.9 kB │ 5.02 MB │ └───────────┴─────────┴─────────┴─────────┴────────┴──────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 9 │ ├────────────┼──────────────┤ │ 2.5 │ 9 │ ├────────────┼──────────────┤ │ 10 │ 10 │ ├────────────┼──────────────┤ │ 25 │ 10 │ ├────────────┼──────────────┤ │ 50 │ 10 │ ├────────────┼──────────────┤ │ 75 │ 11 │ ├────────────┼──────────────┤ │ 90 │ 11 │ ├────────────┼──────────────┤ │ 97.5 │ 12 │ ├────────────┼──────────────┤ │ 99 │ 13 │ ├────────────┼──────────────┤ │ 99.9 │ 14 │ ├────────────┼──────────────┤ │ 99.99 │ 19 │ ├────────────┼──────────────┤ │ 99.999 │ 22 │ └────────────┴──────────────┘ 137k requests in 15.01s, 76.9 MB read ``` ## Get by id with caching One row by its primary key, on a table with `enableCaching: true` : answered from Redis after the first request. [About this API](https://docs.apimaker.dev/v4/docs/features/automatic-caching.html). ### Get by id with caching : public No token : the API is public. Each answer : 278 bytes (MongoDB), status 200. **MongoDB** Requests / second 26,444 400,693 requests in 15 s Latency p50 3ms average 3.2 ms Latency p99 5ms max 15 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **26,714** · 2 : **26,174** req/s · spread 2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.4 vCPU**, **126 MB** RSS · MongoDB **0.0 vCPU** · sandboxes **0.0 vCPU**, **477 MB** · Redis **0.2 vCPU** · whole server busy **95 %**, of which kernel (network, disk) **26 %** · memory used **1377 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get by id with caching, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public_cached/get-by-id/60ae2488c37cd955cc144161" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_public_cached/get-by-id/60ae2488c37cd955cc144161 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 3 ms │ 5 ms │ 5 ms │ 3.24 ms │ 0.87 ms │ 15 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬────────┬───────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼────────┼───────────┼────────┼─────────┤ │ Req/Sec │ 26,255 │ 26,255 │ 26,687 │ 28,527 │ 26,714.14 │ 523.24 │ 26,252 │ ├───────────┼─────────┼─────────┼─────────┼────────┼───────────┼────────┼─────────┤ │ Bytes/Sec │ 15.6 MB │ 15.6 MB │ 15.9 MB │ 17 MB │ 15.9 MB │ 313 kB │ 15.6 MB │ └───────────┴─────────┴─────────┴─────────┴────────┴───────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 1 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 2 │ ├────────────┼──────────────┤ │ 25 │ 3 │ ├────────────┼──────────────┤ │ 50 │ 3 │ ├────────────┼──────────────┤ │ 75 │ 4 │ ├────────────┼──────────────┤ │ 90 │ 4 │ ├────────────┼──────────────┤ │ 97.5 │ 5 │ ├────────────┼──────────────┤ │ 99 │ 5 │ ├────────────┼──────────────┤ │ 99.9 │ 7 │ ├────────────┼──────────────┤ │ 99.99 │ 12 │ ├────────────┼──────────────┤ │ 99.999 │ 15 │ └────────────┴──────────────┘ 401k requests in 15.01s, 239 MB read ``` **PostgreSQL** Requests / second 26,617 399,693 requests in 15 s Latency p50 3ms average 3.3 ms Latency p99 5ms max 15 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **26,651** · 2 : **26,582** req/s · spread 0.3 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.4 vCPU**, **121 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.0 vCPU** · sandboxes **0.0 vCPU**, **445 MB** · Redis **0.2 vCPU** · whole server busy **95 %**, of which kernel (network, disk) **28 %** · memory used **1642 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get by id with caching, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public_cached/get-by-id/2" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_public_cached/get-by-id/2 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 3 ms │ 5 ms │ 5 ms │ 3.25 ms │ 0.87 ms │ 15 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬────────┬─────────┬──────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼────────┼─────────┼──────────┼────────┼─────────┤ │ Req/Sec │ 25,327 │ 25,327 │ 26,607 │ 27,759 │ 26,651.2 │ 571.73 │ 25,312 │ ├───────────┼─────────┼─────────┼────────┼─────────┼──────────┼────────┼─────────┤ │ Bytes/Sec │ 14.3 MB │ 14.3 MB │ 15 MB │ 15.6 MB │ 15 MB │ 323 kB │ 14.3 MB │ └───────────┴─────────┴─────────┴────────┴─────────┴──────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 1 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 2 │ ├────────────┼──────────────┤ │ 25 │ 3 │ ├────────────┼──────────────┤ │ 50 │ 3 │ ├────────────┼──────────────┤ │ 75 │ 4 │ ├────────────┼──────────────┤ │ 90 │ 4 │ ├────────────┼──────────────┤ │ 97.5 │ 5 │ ├────────────┼──────────────┤ │ 99 │ 5 │ ├────────────┼──────────────┤ │ 99.9 │ 7 │ ├────────────┼──────────────┤ │ 99.99 │ 12 │ ├────────────┼──────────────┤ │ 99.999 │ 15 │ └────────────┴──────────────┘ 400k requests in 15.01s, 225 MB read ``` **MySQL** Requests / second 27,185 416,448 requests in 15 s Latency p50 3ms average 3.1 ms Latency p99 5ms max 17 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **27,764** · 2 : **26,606** req/s · spread 4.3 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.4 vCPU**, **125 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.0 vCPU** · sandboxes **0.0 vCPU**, **502 MB** · Redis **0.2 vCPU** · whole server busy **95 %**, of which kernel (network, disk) **26 %** · memory used **1984 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get by id with caching, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public_cached/get-by-id/2" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_public_cached/get-by-id/2 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼────────┼─────────┼───────┤ │ Latency │ 2 ms │ 3 ms │ 5 ms │ 5 ms │ 3.1 ms │ 0.88 ms │ 17 ms │ └─────────┴──────┴──────┴───────┴──────┴────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬──────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼──────────┼─────────┤ │ Req/Sec │ 26,319 │ 26,319 │ 26,959 │ 32,575 │ 27,763.74 │ 1,993.71 │ 26,319 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼──────────┼─────────┤ │ Bytes/Sec │ 14.8 MB │ 14.8 MB │ 15.2 MB │ 18.4 MB │ 15.6 MB │ 1.12 MB │ 14.8 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴──────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 1 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 2 │ ├────────────┼──────────────┤ │ 25 │ 3 │ ├────────────┼──────────────┤ │ 50 │ 3 │ ├────────────┼──────────────┤ │ 75 │ 4 │ ├────────────┼──────────────┤ │ 90 │ 4 │ ├────────────┼──────────────┤ │ 97.5 │ 5 │ ├────────────┼──────────────┤ │ 99 │ 5 │ ├────────────┼──────────────┤ │ 99.9 │ 6 │ ├────────────┼──────────────┤ │ 99.99 │ 12 │ ├────────────┼──────────────┤ │ 99.999 │ 15 │ └────────────┴──────────────┘ 417k requests in 15.01s, 234 MB read ``` ### Get by id with caching : both tokens With `x-am-authorization` and `x-am-user-authorization`, both checked on every request. Each answer : 278 bytes (MongoDB), status 200. **MongoDB** Requests / second 20,887 313,831 requests in 15 s Latency p50 4ms average 4.3 ms Latency p99 7ms max 18 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **20,852** · 2 : **20,922** req/s · spread 0.3 % · the output below is round 2, the closer to the average (Server during this run) API Maker **3.5 vCPU**, **127 MB** RSS · MongoDB **0.0 vCPU** · sandboxes **0.0 vCPU**, **477 MB** · Redis **0.1 vCPU** · whole server busy **97 %**, of which kernel (network, disk) **22 %** · memory used **1484 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · get by id with caching, both tokens · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_cached/get-by-id/60ae2488c37cd955cc144161" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/customers_cached/get-by-id/60ae2488c37cd955cc144161 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 4 ms │ 6 ms │ 7 ms │ 4.28 ms │ 1.09 ms │ 18 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼────────┼─────────┤ │ Req/Sec │ 20,591 │ 20,591 │ 20,831 │ 21,599 │ 20,922.14 │ 294.96 │ 20,587 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼────────┼─────────┤ │ Bytes/Sec │ 12.3 MB │ 12.3 MB │ 12.4 MB │ 12.9 MB │ 12.5 MB │ 178 kB │ 12.3 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 3 │ ├────────────┼──────────────┤ │ 25 │ 4 │ ├────────────┼──────────────┤ │ 50 │ 4 │ ├────────────┼──────────────┤ │ 75 │ 5 │ ├────────────┼──────────────┤ │ 90 │ 6 │ ├────────────┼──────────────┤ │ 97.5 │ 6 │ ├────────────┼──────────────┤ │ 99 │ 7 │ ├────────────┼──────────────┤ │ 99.9 │ 8 │ ├────────────┼──────────────┤ │ 99.99 │ 13 │ ├────────────┼──────────────┤ │ 99.999 │ 16 │ └────────────┴──────────────┘ 314k requests in 15.01s, 187 MB read ``` **PostgreSQL** Requests / second 21,238 316,378 requests in 15 s Latency p50 4ms average 4.2 ms Latency p99 7ms max 17 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **21,093** · 2 : **21,383** req/s · spread 1.4 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.5 vCPU**, **120 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **0.0 vCPU** · sandboxes **0.0 vCPU**, **445 MB** · Redis **0.1 vCPU** · whole server busy **97 %**, of which kernel (network, disk) **23 %** · memory used **1644 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · get by id with caching, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_cached/get-by-id/2" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.customers_cached/get-by-id/2 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 4 ms │ 6 ms │ 7 ms │ 4.24 ms │ 1.07 ms │ 17 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤ │ Req/Sec │ 20,879 │ 20,879 │ 21,055 │ 21,471 │ 21,092.8 │ 148.64 │ 20,864 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤ │ Bytes/Sec │ 11.7 MB │ 11.7 MB │ 11.9 MB │ 12.1 MB │ 11.9 MB │ 85.5 kB │ 11.7 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 3 │ ├────────────┼──────────────┤ │ 25 │ 4 │ ├────────────┼──────────────┤ │ 50 │ 4 │ ├────────────┼──────────────┤ │ 75 │ 5 │ ├────────────┼──────────────┤ │ 90 │ 6 │ ├────────────┼──────────────┤ │ 97.5 │ 6 │ ├────────────┼──────────────┤ │ 99 │ 7 │ ├────────────┼──────────────┤ │ 99.9 │ 8 │ ├────────────┼──────────────┤ │ 99.99 │ 14 │ ├────────────┼──────────────┤ │ 99.999 │ 16 │ └────────────┴──────────────┘ 316k requests in 15.02s, 178 MB read ``` **MySQL** Requests / second 22,684 345,677 requests in 15 s Latency p50 4ms average 3.8 ms Latency p99 6ms max 15 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **23,046** · 2 : **22,322** req/s · spread 3.2 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.5 vCPU**, **126 MB** RSS · MongoDB **0.0 vCPU** · MySQL **0.0 vCPU** · sandboxes **0.0 vCPU**, **502 MB** · Redis **0.1 vCPU** · whole server busy **97 %**, of which kernel (network, disk) **23 %** · memory used **1984 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · get by id with caching, both tokens · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -H "x-am-authorization: " -H "x-am-user-authorization: " "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_cached/get-by-id/2" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/customers_cached/get-by-id/2 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬───────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼───────┼───────┤ │ Latency │ 2 ms │ 4 ms │ 6 ms │ 6 ms │ 3.84 ms │ 1 ms │ 15 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴───────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼────────┼─────────┤ │ Req/Sec │ 22,255 │ 22,255 │ 22,895 │ 25,599 │ 23,045.87 │ 827.62 │ 22,254 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼────────┼─────────┤ │ Bytes/Sec │ 12.5 MB │ 12.5 MB │ 12.9 MB │ 14.4 MB │ 13 MB │ 466 kB │ 12.5 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 3 │ ├────────────┼──────────────┤ │ 25 │ 3 │ ├────────────┼──────────────┤ │ 50 │ 4 │ ├────────────┼──────────────┤ │ 75 │ 4 │ ├────────────┼──────────────┤ │ 90 │ 5 │ ├────────────┼──────────────┤ │ 97.5 │ 6 │ ├────────────┼──────────────┤ │ 99 │ 6 │ ├────────────┼──────────────┤ │ 99.9 │ 8 │ ├────────────┼──────────────┤ │ 99.99 │ 12 │ ├────────────┼──────────────┤ │ 99.999 │ 15 │ └────────────┴──────────────┘ 346k requests in 15.01s, 195 MB read ``` ## Insert one row `POST …/
/save-single-or-multiple` with one row of 9 columns in the body : the schema checks and converts it, the database writes it, and the saved row is answered. [About this API](https://docs.apimaker.dev/v4/docs/apis-all/schema-apis/auto-generated-schema-based-save-single-or-multiple-api.html). No token : the API is public. Each answer : 277 bytes (MongoDB), status 201. **MongoDB** Requests / second 3,198 47,640 requests in 15 s Latency p50 30ms average 31.0 ms Latency p99 63ms max 143 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **3,177** · 2 : **3,219** req/s · spread 1.3 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.3 vCPU**, **130 MB** RSS · MongoDB **2.1 vCPU** · sandboxes **0.0 vCPU**, **476 MB** · whole server busy **96 %**, of which kernel (network, disk) **28 %** · memory used **1412 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MongoDB · insert one row, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -m POST -b '{"customer_id":1,"first_name":"BENCH","last_name":"INSERT","phone":1123456789,"last_update":"2006-02-15T04:34:00.330Z","pincode":111111,"shipping_id":2,"dob":"2022-10-30T03:25:03.000Z","country":"India"}' -H "content-type: application/json" "http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/inserts_public/save-single-or-multiple" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mongodb/am_bench/inserts_public/save-single-or-multiple 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬──────────┬────────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼──────────┼────────┤ │ Latency │ 15 ms │ 30 ms │ 53 ms │ 63 ms │ 30.96 ms │ 10.01 ms │ 143 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴──────────┴────────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤ │ Req/Sec │ 3,063 │ 3,063 │ 3,163 │ 3,375 │ 3,176.47 │ 71.37 │ 3,062 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤ │ Bytes/Sec │ 1.83 MB │ 1.83 MB │ 1.89 MB │ 2.02 MB │ 1.9 MB │ 42.6 kB │ 1.83 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 2 │ ├────────────┼──────────────┤ │ 0.01 │ 6 │ ├────────────┼──────────────┤ │ 0.1 │ 9 │ ├────────────┼──────────────┤ │ 1 │ 13 │ ├────────────┼──────────────┤ │ 2.5 │ 15 │ ├────────────┼──────────────┤ │ 10 │ 20 │ ├────────────┼──────────────┤ │ 25 │ 24 │ ├────────────┼──────────────┤ │ 50 │ 30 │ ├────────────┼──────────────┤ │ 75 │ 36 │ ├────────────┼──────────────┤ │ 90 │ 43 │ ├────────────┼──────────────┤ │ 97.5 │ 53 │ ├────────────┼──────────────┤ │ 99 │ 63 │ ├────────────┼──────────────┤ │ 99.9 │ 89 │ ├────────────┼──────────────┤ │ 99.99 │ 122 │ ├────────────┼──────────────┤ │ 99.999 │ 143 │ └────────────┴──────────────┘ 48k requests in 15.02s, 28.5 MB read ``` **PostgreSQL** Requests / second 3,969 60,055 requests in 15 s Latency p50 24ms average 24.5 ms Latency p99 28ms max 34 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **4,004** · 2 : **3,935** req/s · spread 1.8 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.5 vCPU**, **123 MB** RSS · MongoDB **0.0 vCPU** · PostgreSQL **1.4 vCPU** · sandboxes **0.0 vCPU**, **444 MB** · whole server busy **91 %**, of which kernel (network, disk) **32 %** · memory used **1646 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · PostgreSQL · insert one row, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -m POST -b '{"first_name":"BENCH","last_name":"INSERT","phone":1123456789,"last_update":"2006-02-15T04:34:00.330Z","pincode":111111,"shipping_id":2,"dob":"2022-10-30T03:25:03.000Z","country":"India"}' -H "content-type: application/json" "http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.inserts_public/save-single-or-multiple" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/postgres/am_bench/public.inserts_public/save-single-or-multiple 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬──────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼──────────┼─────────┼───────┤ │ Latency │ 23 ms │ 24 ms │ 27 ms │ 28 ms │ 24.46 ms │ 1.51 ms │ 34 ms │ └─────────┴───────┴───────┴───────┴───────┴──────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤ │ Req/Sec │ 3,883 │ 3,883 │ 4,009 │ 4,059 │ 4,004.07 │ 46.53 │ 3,883 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼─────────┼─────────┤ │ Bytes/Sec │ 2.21 MB │ 2.21 MB │ 2.28 MB │ 2.31 MB │ 2.28 MB │ 26.4 kB │ 2.21 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 2 │ ├────────────┼──────────────┤ │ 0.01 │ 2 │ ├────────────┼──────────────┤ │ 0.1 │ 6 │ ├────────────┼──────────────┤ │ 1 │ 22 │ ├────────────┼──────────────┤ │ 2.5 │ 23 │ ├────────────┼──────────────┤ │ 10 │ 23 │ ├────────────┼──────────────┤ │ 25 │ 24 │ ├────────────┼──────────────┤ │ 50 │ 24 │ ├────────────┼──────────────┤ │ 75 │ 25 │ ├────────────┼──────────────┤ │ 90 │ 26 │ ├────────────┼──────────────┤ │ 97.5 │ 27 │ ├────────────┼──────────────┤ │ 99 │ 28 │ ├────────────┼──────────────┤ │ 99.9 │ 31 │ ├────────────┼──────────────┤ │ 99.99 │ 33 │ ├────────────┼──────────────┤ │ 99.999 │ 34 │ └────────────┴──────────────┘ 60k requests in 15.01s, 34.2 MB read ``` **MySQL** Requests / second 3,181 47,899 requests in 15 s Latency p50 31ms average 30.8 ms Latency p99 35ms max 40 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **3,194** · 2 : **3,168** req/s · spread 0.8 % · the output below is round 1, the closer to the average (Server during this run) API Maker **1.3 vCPU**, **128 MB** RSS · MongoDB **0.0 vCPU** · MySQL **1.2 vCPU** · sandboxes **0.0 vCPU**, **502 MB** · whole server busy **84 %**, of which kernel (network, disk) **33 %** · memory used **1989 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · MySQL · insert one row, public · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l -m POST -b '{"first_name":"BENCH","last_name":"INSERT","phone":1123456789,"last_update":"2006-02-15T04:34:00.330Z","pincode":111111,"shipping_id":2,"dob":"2022-10-30T03:25:03.000Z","country":"India"}' -H "content-type: application/json" "http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/inserts_public/save-single-or-multiple" Running 15s test @ http://192.168.133.150:38246/api/schema/bench/mysql/am_bench/inserts_public/save-single-or-multiple 100 connections 10 workers ┌─────────┬───────┬───────┬───────┬───────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼───────┼───────┼───────┼───────┼─────────┼─────────┼───────┤ │ Latency │ 28 ms │ 31 ms │ 34 ms │ 35 ms │ 30.8 ms │ 1.98 ms │ 40 ms │ └─────────┴───────┴───────┴───────┴───────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤ │ Req/Sec │ 3,065 │ 3,065 │ 3,199 │ 3,315 │ 3,193.8 │ 57.59 │ 3,064 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤ │ Bytes/Sec │ 1.74 MB │ 1.74 MB │ 1.82 MB │ 1.89 MB │ 1.82 MB │ 32.7 kB │ 1.74 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 2 │ ├────────────┼──────────────┤ │ 0.01 │ 3 │ ├────────────┼──────────────┤ │ 0.1 │ 5 │ ├────────────┼──────────────┤ │ 1 │ 28 │ ├────────────┼──────────────┤ │ 2.5 │ 28 │ ├────────────┼──────────────┤ │ 10 │ 29 │ ├────────────┼──────────────┤ │ 25 │ 30 │ ├────────────┼──────────────┤ │ 50 │ 31 │ ├────────────┼──────────────┤ │ 75 │ 32 │ ├────────────┼──────────────┤ │ 90 │ 33 │ ├────────────┼──────────────┤ │ 97.5 │ 34 │ ├────────────┼──────────────┤ │ 99 │ 35 │ ├────────────┼──────────────┤ │ 99.9 │ 37 │ ├────────────┼──────────────┤ │ 99.99 │ 38 │ ├────────────┼──────────────┤ │ 99.999 │ 40 │ └────────────┴──────────────┘ 48k requests in 15.02s, 27.3 MB read ``` ## Custom API without a database A public custom API whose code returns a small object and reads no database : what running code of the account costs, without a database. Lean code runs in the server itself, with QuickJS ; the same code with `Date.now()` in it runs in a sandbox of the account : the trip from API Maker to the runner in its container and back. **In the server (lean code)** **The custom API** ```typescript import * as T from 'types'; async function main(g: T.IAMGlobal) { return { message: 'Hello from API Maker', time: 1 }; } module.exports = main; ``` Requests / second 26,046 394,004 requests in 15 s Latency p50 3ms average 3.3 ms Latency p99 6ms max 16 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **26,268** · 2 : **25,824** req/s · spread 1.7 % · the output below is round 1, the closer to the average (Server during this run) API Maker **3.9 vCPU**, **123 MB** RSS · MongoDB **0.0 vCPU** · sandboxes **0.0 vCPU**, **601 MB** · whole server busy **99 %**, of which kernel (network, disk) **23 %** · memory used **1578 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · custom API without a database, in the server (lean code) · round 1 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/custom-api/bench/bench_no_db" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_no_db 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤ │ Latency │ 1 ms │ 3 ms │ 6 ms │ 6 ms │ 3.31 ms │ 1.32 ms │ 16 ms │ └─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼────────┼─────────┤ │ Req/Sec │ 25,935 │ 25,935 │ 26,143 │ 27,055 │ 26,268.27 │ 311 │ 25,931 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼────────┼─────────┤ │ Bytes/Sec │ 10.3 MB │ 10.3 MB │ 10.4 MB │ 10.8 MB │ 10.5 MB │ 124 kB │ 10.3 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 0 │ ├────────────┼──────────────┤ │ 1 │ 0 │ ├────────────┼──────────────┤ │ 2.5 │ 1 │ ├────────────┼──────────────┤ │ 10 │ 2 │ ├────────────┼──────────────┤ │ 25 │ 2 │ ├────────────┼──────────────┤ │ 50 │ 3 │ ├────────────┼──────────────┤ │ 75 │ 4 │ ├────────────┼──────────────┤ │ 90 │ 5 │ ├────────────┼──────────────┤ │ 97.5 │ 6 │ ├────────────┼──────────────┤ │ 99 │ 6 │ ├────────────┼──────────────┤ │ 99.9 │ 8 │ ├────────────┼──────────────┤ │ 99.99 │ 12 │ ├────────────┼──────────────┤ │ 99.999 │ 14 │ └────────────┴──────────────┘ 394k requests in 15.01s, 157 MB read ``` **In the sandbox** **The custom API** ```typescript import * as T from 'types'; async function main(g: T.IAMGlobal) { return { message: 'Hello from the sandbox', time: Date.now() }; } module.exports = main; ``` Requests / second 17,702 265,205 requests in 15 s Latency p50 5ms average 5.2 ms Latency p99 10ms max 17 ms Errors 0 non-2xx, errors, timeouts (2 rounds of 15 s) 1 : **17,723** · 2 : **17,681** req/s · spread 0.2 % · the output below is round 2, the closer to the average (Server during this run) API Maker **3.0 vCPU**, **125 MB** RSS · MongoDB **0.0 vCPU** · sandboxes **0.9 vCPU**, **600 MB** · whole server busy **98 %**, of which kernel (network, disk) **21 %** · memory used **1594 MB** of 7941 MB · steal **0 %** · swap not touched autocannon · custom API without a database, in the sandbox · round 2 of 2, the closer to the average ```text $ autocannon -c 100 -d 15 -w 10 -l "http://192.168.133.150:38246/api/custom-api/bench/bench_sandbox_no_db" Running 15s test @ http://192.168.133.150:38246/api/custom-api/bench/bench_sandbox_no_db 100 connections 10 workers ┌─────────┬──────┬──────┬───────┬───────┬─────────┬─────────┬───────┐ │ Stat │ 2.5% │ 50% │ 97.5% │ 99% │ Avg │ Stdev │ Max │ ├─────────┼──────┼──────┼───────┼───────┼─────────┼─────────┼───────┤ │ Latency │ 2 ms │ 5 ms │ 9 ms │ 10 ms │ 5.16 ms │ 1.86 ms │ 17 ms │ └─────────┴──────┴──────┴───────┴───────┴─────────┴─────────┴───────┘ ┌───────────┬─────────┬─────────┬─────────┬─────────┬───────────┬─────────┬─────────┐ │ Stat │ 1% │ 2.5% │ 50% │ 97.5% │ Avg │ Stdev │ Min │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼─────────┼─────────┤ │ Req/Sec │ 17,455 │ 17,455 │ 17,615 │ 18,127 │ 17,680.54 │ 177.97 │ 17,455 │ ├───────────┼─────────┼─────────┼─────────┼─────────┼───────────┼─────────┼─────────┤ │ Bytes/Sec │ 7.21 MB │ 7.21 MB │ 7.27 MB │ 7.48 MB │ 7.3 MB │ 73.2 kB │ 7.21 MB │ └───────────┴─────────┴─────────┴─────────┴─────────┴───────────┴─────────┴─────────┘ Req/Bytes counts sampled once per second. # of samples: 150 ┌────────────┬──────────────┐ │ Percentile │ Latency (ms) │ ├────────────┼──────────────┤ │ 0.001 │ 0 │ ├────────────┼──────────────┤ │ 0.01 │ 0 │ ├────────────┼──────────────┤ │ 0.1 │ 1 │ ├────────────┼──────────────┤ │ 1 │ 2 │ ├────────────┼──────────────┤ │ 2.5 │ 2 │ ├────────────┼──────────────┤ │ 10 │ 3 │ ├────────────┼──────────────┤ │ 25 │ 4 │ ├────────────┼──────────────┤ │ 50 │ 5 │ ├────────────┼──────────────┤ │ 75 │ 6 │ ├────────────┼──────────────┤ │ 90 │ 8 │ ├────────────┼──────────────┤ │ 97.5 │ 9 │ ├────────────┼──────────────┤ │ 99 │ 10 │ ├────────────┼──────────────┤ │ 99.9 │ 12 │ ├────────────┼──────────────┤ │ 99.99 │ 15 │ ├────────────┼──────────────┤ │ 99.999 │ 17 │ └────────────┴──────────────┘ 265k requests in 15.01s, 110 MB read ``` ## More connections *Get all, public* and *Get by id with caching, public* on MongoDB, one run of 15 seconds for each number of connections. More clients at once wait longer for their answer, and the server keeps answering them all. ### Get all, public, by connections **Get all, public, MongoDB : requests per second by connections** 10 connectionsp50 1 ms · p99 3 ms · 5,580 50 connectionsp50 6 ms · p99 16 ms · 6,813 100 connectionsp50 14 ms · p99 34 ms · 6,814 250 connectionsp50 35 ms · p99 56 ms · 6,952 500 connectionsp50 76 ms · p99 95 ms · 6,538 1,000 connectionsp50 152 ms · p99 174 ms · 6,525 | Connections | Requests / second | p50 | p99 | Max | Errors | Server busy | API Maker RSS | |--:|--:|--:|--:|--:|--:|--:|--:| | 10 | **5,580** | 1 ms | 3 ms | 8 ms | 0 | 87 % | 123 MB | | 50 | **6,813** | 6 ms | 16 ms | 34 ms | 0 | 98 % | 126 MB | | 100 | **6,814** | 14 ms | 34 ms | 84 ms | 0 | 99 % | 131 MB | | 250 | **6,952** | 35 ms | 56 ms | 96 ms | 0 | 99 % | 144 MB | | 500 | **6,538** | 76 ms | 95 ms | 141 ms | 0 | 99 % | 157 MB | | 1,000 | **6,525** | 152 ms | 174 ms | 224 ms | 0 | 99 % | 196 MB | ### Get by id with caching, public, by connections **Get by id with caching, public, MongoDB : requests per second by connections** 10 connectionsp50 0 ms · p99 1 ms · 11,584 50 connectionsp50 1 ms · p99 3 ms · 24,945 100 connectionsp50 3 ms · p99 5 ms · 28,147 250 connectionsp50 8 ms · p99 12 ms · 30,600 500 connectionsp50 16 ms · p99 22 ms · 29,908 1,000 connectionsp50 36 ms · p99 46 ms · 27,033 | Connections | Requests / second | p50 | p99 | Max | Errors | Server busy | API Maker RSS | |--:|--:|--:|--:|--:|--:|--:|--:| | 10 | **11,584** | 0 ms | 1 ms | 6 ms | 0 | 68 % | 131 MB | | 50 | **24,945** | 1 ms | 3 ms | 10 ms | 0 | 91 % | 131 MB | | 100 | **28,147** | 3 ms | 5 ms | 15 ms | 0 | 95 % | 134 MB | | 250 | **30,600** | 8 ms | 12 ms | 31 ms | 0 | 97 % | 143 MB | | 500 | **29,908** | 16 ms | 22 ms | 49 ms | 0 | 97 % | 157 MB | | 1,000 | **27,033** | 36 ms | 46 ms | 101 ms | 0 | 97 % | 184 MB | ## Questions ### How many requests per second can API Maker serve on 4 shared vCPUs ? On this 8 GB server, with the database on the same machine : 7,423 requests per second for a whole table of ten rows on MongoDB (PostgreSQL 8,395 · MySQL 9,375), 8,076 for one row by its id, and 26,444 when the answer is cached in Redis. A custom API in TypeScript which reads the table answers 5,178 requests per second when API Maker runs it itself (lean code), 4,649 when it runs in the sandbox of the account. ### How much memory does API Maker use ? The API Maker process held 109 MB at rest and 142 MB at most under load on this server, in RAM. The rest of the memory went to the databases (MongoDB, Redis, PostgreSQL or MySQL), the sandboxes which run the code of the account, and Linux itself. ### Do the two tokens slow the APIs down ? API Maker checks both tokens (x-am-authorization and x-am-user-authorization) and the groups of the API user on every request. Get all with both tokens answered 7,021 requests per second on MongoDB (public : 7,423), 7,680 requests per second on PostgreSQL (public : 8,395), 8,338 requests per second on MySQL (public : 9,375). The checks show most where the database does no work : a cached get all answered 20,550 requests per second with both tokens against 26,115 public on MongoDB. ### What does a pre hook cost ? A pre hook runs code of the account before the API ; a lean hook like this one runs in the server itself, with QuickJS. Get all with a row scoping pre hook answered 5,327 requests per second on MongoDB, against 7,021 for the same API without the hook. On 4 vCPUs, the API, the hook and the database share the same 4 vCPUs. ### Can I run these benchmarks myself ? Yes : [How API Maker is benchmarked](https://docs.apimaker.dev/v4/docs/benchmarks/methodology.html) gives the dataset, the settings of every API and the exact autocannon commands.