API Maker

The backend engine for the AI era

Code scanEpisode 64 9:18 12 chapters November 2026

Scan Your API Code for Leaks in 8 Languages, Fix It in One Click

The APIs Security Report of API Maker reads the code of your account in TypeScript, Python, PHP, C#, Go, Rust, Java and Kotlin, finds what it leaks on its own at its line, and fixes it in one click, in the language it is written in. On Calm Home: TLS checks off, SQL put together from the request, a key in the code, and row scoping hooks graded, rewritten and written in Python and Go.

In the playlists The complete course Security & access

Chapters

What you will learn

  • The scan of the code: every piece of code of the account, in eight languages
  • Twenty rules, in six families
  • A fix seen before it is saved, and saved where the code is kept
  • SQL put together from the request, a secret in the code
  • Row scoping hooks graded, rewritten and written in any language
  • A public custom API needs a token again
  • Code written by AI assistants, graded by the next scan
In the docsAPIs Security Report & Actions
Transcript1405 words · click a time to play from there

Intro

The security report now reads your code, in all eight languages that API Maker runs. It finds what the code leaks by itself, at its line. And it fixes it in one click, in the language it is written in.

Settings are half of the story

Settings are only half of the story. The code decides what an API does, and it can leak by itself. A key can be written in the code. SQL can be built from the request. A call can turn off the checks of TLS. A hook can trust the body. And the code of one account is written by several teams, in several languages, by people and by AI assistants.

A reviewer reads only one or two of them. API Maker reads all eight. It points at the line. It shows the fix before it is saved. And it saves it through the page of the code. In this video: the code of Calm Home, the scan of the code and its rules, a fix seen before it is saved, SQL and secrets, hooks in every language, a public API, and what it means for AI assistants.

The code of Calm Home

Calm Home has grown. The warehouse team syncs the stock of a partner, in Python. The marketing team exports the newsletter subscribers, in PHP. The payments team refunds orders, in Go. The support tool searches orders, in TypeScript. And the support team rewrote the hook of support tickets, in Python. Every piece works, and every piece was reviewed by somebody who reads its language.

The scan of the code

In the report, scan again. The scope now counts the pieces of code it read, and their languages. And a new category, Code, asks one more question: what does the code itself leak, in every language? How does one report read eight languages? The scan gathers every piece of code of the account: custom APIs and the hooks of their versions, the hooks of tables and of system APIs, schedulers, events, WebSocket events, utility classes, initializers, migrations, and the functions of auth providers.

A token reader knows the strings, the comments, and the templates of each language. Its rules read the tokens, and every hook is graded the same way, whatever language it is written in. Nothing is run. The code is only read. The rules come in six families. Secrets and tokens: a key in the code, a secret or a token returned, a token in the logs, or an error stack returned.

Rows: the users table read with its passwords, a filter written by the caller, the rows of people read without a limit, a row read by an id that the caller sends, or the body written as it is. Injection: SQL, commands, or code made at run time. Network and files: an address the caller chooses, a file the caller names, or the checks of TLS turned off. Crypto: weak password hashes, and random tokens that can be guessed.

And hooks: one that changes who the caller is, and one that a caller can turn off.

A fix, seen first

Open the finding of Partner stock sync. The top names the custom API, the line, six, and the language, Python. The evidence shows the line as it is written: verify equals False. And the fix is one button: turn the checks of TLS back on. Click it. Before anything is saved, the dialog shows the code now, on the left, and after the fix, on the right. One word changes, on line six.

Click Apply and scan again. The code is saved, and the next scan lists the finding under Fixed. Where does the fix go? It goes into the code of the custom API, and into its version in use, which is the code that runs. The same is true for a scheduler, or a listener of an event. A hook of a version of a custom API is changed in that version.

Then the code is saved through the route of its own page. It is compiled and checked as when you save it there, with the rule of one language for each API. It goes to Git and to the local client, and the account is scanned again. And what if the code changed since the scan? A fix carries a fingerprint of the code it was made for. When the code changed somewhere else, the fix still lands, as long as the text it replaces is still in its place.

Otherwise, it is refused, and the report asks for a new scan. A fix never lands on code it was not made for.

SQL and secrets

Here is the export of the marketing team, in PHP. SQL is built from what the caller sends. It is critical. The line pastes the parameter since into the text of the statement. How it is exploited names this very API, and this very parameter. One value can end the text, and add its own SQL. The remedy says how to fix it: read with g.sys.db and a find, where API Maker binds every value.

In the Go code of the payments team, the code holds a secret. The report never shows it. The value is masked, on the page, and in the report in Git. The suggested code reads it from Secret Management, in Go. And the remedy says to rotate it, because it has been in Git.

Hooks, in every language

Now the hooks. A hook decides whose rows a request reaches, and API Maker runs hooks in eight languages. The report reads every one of

Hooks in every language

them in the same way. Support tickets is limited for only some of its APIs. The card of the hook says Python, and the report reads it the way it reads TypeScript. It reads the person, and filters get all, but not query, and it merges with a spread. Rewrite the hook to cover every API shows the code now, and after, in Python. The hook keeps its name, its groups, and its place.

Apply, and now support tickets is limited for every API. Orders has no hook yet. Add a row scoping pre-hook opens on its settings. Its Code tab offers the eight languages. When hooks already run for a table, their language is taken, and locked, because one API runs the code of one language. Here, none does, so pick Go. The code is written again in Go, and the chips say what the report reads in it.

It limits rows, for every family of APIs. Click Apply. The pre-hook is added, in Go. Some fixes are one idea in eight languages. A hook without the guard for inside calls also limits custom APIs, schedulers, and events, which carry no person. Let the internal calls through adds one guard at the top of main, in the language of the hook, and changes nothing else. Is the code that the report writes right, in every language?

The row scoping hook is run by the runner of each language, against every family of APIs: get all, query, update many, saves, aggregate, and a call without a person. And the API test sheets add it from the report, call orders as two customers through it, rewrite it, and guard it, in each of the eight languages.

A public API

Store status answers without a token. That is fine for a health check, but worth a look for anything else. Require a token changes one word of its Basic Info, and you see it first. Now every caller needs a token again.

AI assistants

This matters even more with AI assistants. They write code in any language, and fast. The report reads it like any other code. It writes the line and the fix into report.md, in Git. And the next scan grades what the assistant changed.

Best practices

Here are the best practices. Keep secrets in Secret Management, never in the code. Never put a value from the request into the text of SQL. Keep the checks of TLS on. Never let a caller write a filter alone. Use the generated hook, in the language of your API. And read every fix before it is saved. The dialog shows it.

Recap

That was the scan of the code. It reads every piece of code, in eight languages. Every rule points at the line. You see each fix before it is saved, and it is made where the code is kept. Hooks are graded, rewritten, and written in your language. Next, the other security features. API Maker. Build faster, spend smarter, deliver better.