API Maker

The backend engine for the AI era

Full demo 14:30 39 chapters November 2026

API Maker Demo: From Install to APIs Across Six Databases

The tour of the first API Maker demo, recorded again on API Maker v4. Install it with Launchpad, open the dashboard, connect a database and get the APIs of every table, read across six databases in one call, filter and save across engines, write a custom API and see where it spends its time, then the IDE and debugger, schedulers and WebSockets, websites rendered on the server, Index Maker, analytics, a Git pull on every server and engine upgrades.

Next: Panel tour Read the docs

In the playlists Start here

Chapters

What you will learn

  • Install API Maker with Launchpad and open its admin panel
  • Connect SQL Server and get the APIs of every table, with schemas in one click
  • Use the query parameters of Get all, the envelope of every answer, and deep populate across six databases on one screen
  • Filter across databases, and save a customer with her order in one call
  • Write a custom API, test it, see what every custom API gets, and read its timeline on the Index Maker tab
  • The IDE and the debugger, a scheduler from its code to its output, and WebSockets
  • Websites rendered on the server, Index Maker and automatic indexes, and Analytics
  • Deploy with one Git pull on every server, and upgrade the engine from the panel or by API
In the docsYour first API
Transcript1967 words · click a time to play from there

Intro

This is API Maker. You connect your databases, and you get a full backend: APIs, security, live updates, and much more.

Launchpad: a new project

It all starts in API Maker Launchpad. It is a desktop app. It runs API Maker on this computer, or on your own servers. Click New project. Type a name for its folder, and create it.

Launchpad: the setup

Now a short setup. First, choose how it runs: all in Docker, or as a normal program on this computer. Click Next. Give the project a name, and pick the version of API Maker. MongoDB and Redis will run next to it. Next, the ports. If a port is already in use, you see it at once. Last, you check everything before it runs.

Launchpad: install and start

All set. Click Install and start. API Maker downloads. MongoDB and Redis start. In a moment, API Maker is running. One click opens the admin panel.

The dashboard

After you sign in, you see this dashboard. Every page of API Maker opens from here. There are four groups: APIs and logic, security, databases, and operations. You can also type a word to find a page.

A new instance

Now let us make APIs for a database. Open the Instance API page. It lists every database you connected. Click to add a new instance. Pick the database type. Here, it is SQL Server. The connection string comes from a secret, so you never type a password. Give it a name, test the connection, and save it.

Its tables, and their APIs

The new instance is now in the list. Open it, and API Maker reads its databases right away. Open the warehouse database. You see its tables, and how many rows each one has. Even with no schema yet, every table already has its generic APIs.

Bulk Schema Creation

Next, the schemas. A schema says what each column holds. Open Bulk Schema Creation. Select every table, and make all the schemas with one click.

Every table, its APIs

Go back to the inventory table. Now it has the full set of APIs: get all, get by ID, save, update, delete, count, aggregate, and more. The schema APIs check every value with the schema. The generic APIs work without one. And we did not write one line of code.

API Testing

You can try every API right here in the panel. Open API Testing, and choose what to call. First, the instance: MySQL. Then the database: sales. Then the table with the orders. And last, the API: get all.

Query parameters

Get all takes query parameters. Each one does what its name says. Limit the answer to five orders. Sort them by total, the biggest first. And select the fields you want back. Click Send. The five biggest orders come back.

One envelope

Look at the shape of the answer. Every API answers in the same shape: success, a status code, and the data. Errors come back in this same shape too. So your app reads every answer the same way.

Deep populate

Each order keeps only the ID of its customer. The customers are in another database, PostgreSQL. Add deep on customer ID, and send again. Now every order brings its full customer, from the other database.

One call, six databases, one screen

Deep can go as far as you need. Pick the API Query for get data. Open its body. Ask for one order, and five things linked to it. Send. Now the request and the full answer fit on one screen. The order comes from MySQL. Its customer comes from PostgreSQL. The coupon comes from MariaDB. The employee comes from Oracle. The products come from MongoDB. And the shipments come from SQL Server.

One request, one answer, six databases.

Filters across databases

Filters can also work across databases. Open API Testing again. Pick the instance, MySQL. Then the database, sales. Then the orders table. This time, pick the API Query for get data.

Orders of gold customers

Its body takes a filter. This filter asks for the orders of gold customers. But the gold level is saved with the customers, in PostgreSQL. Send. Only the orders of gold customers come back.

Two tables away

A filter can even go two tables away. Here, we ask for the orders of customers who live in Pune. Send. API Maker joins the tables for you, even when they are in different databases.

Master save

You can also save data across databases. Open API Testing, and choose what to call. The instance is PostgreSQL. The database is CRM. The table is customers. And the API is master save.

A customer, her order, its lines

In the body, we write a new customer, her order, and two order lines. Orders and their lines are saved in MySQL. First, a mistake: one quantity is a word, not a number. The error comes back in the same shape. It names the field, and says what is wrong. Nothing is saved anywhere. Now we fix it. One call saves the customer in PostgreSQL, and her order and its lines in MySQL.

Read back

Now let us read it back. Pick Query for get data, and open its body. With deep, we ask for the customer, her orders, and their lines. Send. Everything is there, from both databases.

A custom API

When you need your own logic, you write a custom API. Open Custom API, and add a new one. First, its settings: a name, a path, and a method. Then its code. It reads the orders from MySQL, with the same query parameters. Save it, and it is live.

Test it

From the list, you can test it right away. API Testing opens with it. Its code is on the left. Send, and its answer is on the right.

What every custom API gets

Every custom API also gets all of this, with no extra code: authorization, input validation, ready database and system APIs, automatic caching, translated errors, logs, utility classes, types for every table, and eight languages to write it in.

The timeline of a run

When your custom API works, you may ask: where does it spend its time? API Testing shows you, call by call. Here are two small custom APIs. They count the events of the orders, in a table of a million rows. Test the first one, and send it. When the answer is back, hide the request side, and open the Index Maker tab of the answer. Its timeline shows one bar for each database call.

The calls run one by one. Each count waits for the one before it. It looks like a staircase.

All at once

Open the second API from the menu. It runs the same three counts at the same time, with Promise dot all. Send it. Again, hide the request side, and open the Index Maker tab. Now the timeline shows three bars side by side. The run ends much sooner. So you see how your code loads its data, before your users feel it.

The IDE

New in version four: a full code editor, an IDE, inside the panel. Open API Testing. Go to the custom APIs, and pick Order Quote. Open its code, and click the IDE button. Every file of your account is here, in one tree: custom APIs, events, schedulers, and websites, with their history.

The debugger

When something goes wrong, you can debug it. Open API Testing again. Go to the custom APIs, and pick Cart Total. Open its code. Click in the margin to set a breakpoint. Click Send. The request stops on that line. You can open any variable, run code right where it stopped, go to the next line, watch a value, and continue to the answer. This works in every language API Maker runs.

A scheduler

Some work must run on a timer, not when an API is called. Open Schedulers, and add one. Give it a name, turn it on, and add an interval. We want it every minute, so pick Minute from the list. Then pick the time zone. We find India by its city. Save it. The panel shows the next run times right away.

Its code

Now its code. It reads the paid orders that still need packing, from MySQL. Then it writes how many there are to its log. Save it, and a server picks it up right away.

It runs, and its output

Open it again, and wait for the minute. It runs. The run is in the list, with how long it took. Its logs are one click away. Open the run. The console shows what the code wrote: the orders to pack.

WebSockets

Live updates are also built in. WebSocket events send data to your apps the moment it changes. Here, when an order is saved, and a custom event for its status. An event can have code. Open it, and look at its code. The code decides who can follow the event. Here, a customer follows only their own orders.

Websites rendered on the server

API Maker can also serve websites. You write the pages in TSX, next to your data, and the server builds each page. Here is the Calm Home shop, as a visitor sees it. Every page arrives complete, ready for search engines. One product page reads from four databases. And no API was written for any of it.

Index Maker

Is a query slow? Index Maker records the shape of every query your APIs run. Open the report of a time period. You see the calls to the database, with real samples of the slow one. The Suggestions tab shows the index it needs. Open it in the index form. Keep it out of the migration script for now, and create the index. A moment later, check again. Now the query uses the index.

Automatic indexes

Or let Index Maker do it by itself. In automatic mode, it records the real queries of your APIs from time to time. Its rules decide when a slow query gets an index, and what kind of index. Keep the default rules, and switch it on. Every index it makes goes into a migration script. So development, staging, and production all get the same indexes.

Analytics

How is every server doing? Analytics shows you, from the real traffic of your APIs. Pick the last fifteen minutes, and pause the live refresh. You see the calls, the errors, the speed, and the cache hits. You also see how many rows of data were read from the six databases. Here is the traffic and the speed over time. Here are the busiest and the slowest APIs. And every API has its own numbers, custom APIs too.

Speed beside the code

You also see these numbers next to your code. On the Custom API page, every API shows its speed, its number of calls, and the size of its answers. The details are one click away. In the grid view, sort by speed, and the slowest APIs come first.

One pull, every server

Your code can also live in Git. Open the Git page. This account follows the main branch, and a teammate just pushed a new shipping fee for Cart Quote. Click Pull. The panel shows each step on the server, live. It fetches the new code, checks it, and loads it. A few seconds later, it is done. There was no build, and no restart. Now we call Cart Quote on each server.

This setup runs two servers, and both use the new fee right away. One pull updates every server.

Upgrade Engine

Updating API Maker itself is just as easy. The Upgrade Engine page shows the version that runs now. There are two ways to change it. You can upload a release, or pick a version from npm, newer or older. Every server installs it, and checks that it starts. If it does not start, it goes back by itself. And for your build pipeline, an engine webhook does the same thing, with one call.

By API

Your pipeline calls it, and names the version it needs. The call answers at once. A second call asks how it is going. First, running, while every server installs it. Then restarting, until each server answers on the new version. And then done: every server runs it. Everything you saw starts from this dashboard. API Maker. Build faster, spend smarter, deliver better.