# Developer Tools

> Swagger docs per API user, TypeScript interfaces from your schemas, client code in 21 languages, a debugger for sandbox code, code search and editing in your own editor.

Source: https://docs.apimaker.dev/v4/docs/features/developer-tools.html

What API Maker gives a developer besides the APIs : documentation for the people who call them, types for the code which uses them, a debugger, and a way to work from your own editor.

## Swagger docs per API user

- Open an API user, enable Swagger docs and generate a **Swagger Token**. **View Swagger JSON** opens its URL.
- The docs list only the APIs that the API user can call, like its database, custom and system APIs.
- Share the URL with the team or partner that uses that API user.
- The URL answers only while Swagger docs are enabled for that API user. Disable them, or generate a new token, to stop an old URL from working.

## TypeScript interfaces from your schemas

- Your table schemas become TypeScript interfaces, grouped by instance and database : `db.<instance>.<database>.I<Table>`. See them in `APIs & Logic → Generated Interfaces`.
- Import them from `db-interfaces` in your code.

```typescript
import * as T from 'types';
import * as db from 'db-interfaces';

async function main(g: T.IAMGlobal) {
    const products = await g.sys.db.getAll<db.shop.main.IProducts>({
        instance: 'shop', database: 'main', collection: 'products',
    });
    return products.map(p => p.name); // p is typed
}
module.exports = main;
```

In Python, PHP, C#, Go, Rust, Java and Kotlin the code editor offers the same columns on the rows a call answers, without interfaces to import : [the code editor in every language](https://docs.apimaker.dev/v4/docs/languages/index.html#editor).

## API testing page

- Every API of your account in one place: pick an API, get a sample payload, set the headers and tokens, send it and read the response.
- `APIs & Logic → API Testing`, or **Test API** on the DB API, Custom API, System API, Events and Schedulers pages. On a listener the body holds the event data; on a scheduler, sending runs the code now.
- The request: **Headers**, **Params**, **Query Params**, **Body** (**Generate Data** builds a sample payload from the schema), **Code** (the code of a custom API, listener, scheduler or migration, with its versions), **Pre Hooks** and **Post Hooks** of the API : for an API of a table, the hooks of its instance, its database and its table are listed too, in the order they run (marked **Instance**, **Database**, **Table** : they are changed in their own categories). On a multi-tenant instance, **Select tenant**.
- The response: the answer or the errors, with the status code, the time taken and whether it came from the cache; the TypeScript interface of the answer; **Logs** with every `g.logger` line of the code which ran, hooks included.
- **Index Maker**, for code (a custom API, a listener, a scheduler, a hook...): every database call of the run. What to look at first (a query reading a whole table, a query in a loop, a query asked twice, a slow or big call), a timeline of the calls, every query shape with its index use, and the indexes to create : [one run from the API testing page](https://docs.apimaker.dev/v4/extensions/index_maker/introduction.html#one-run-from-the-api-testing-page).
- A scheduler, a listener, a migration script or a process initializer is sent with the time it runs with (the header `x-am-sandbox-timeout`) : [time of a run](https://docs.apimaker.dev/v4/docs/settings/sandboxSettings.html#time-of-a-run).
- **Show Utility Classes** next to the code opens the [utility classes](https://docs.apimaker.dev/v4/docs/utility-class/utility-class.html#by-language) the code uses : the ones of its language, on its runtime.
- Every **Send** is recorded. Save a request as a state to run it again later, star it as a favourite. States go to Git with the project.
- Copy the same request as client code from **Integrations**: C, C#, cURL, Dart, Go, HTTP, Java, JavaScript, Kotlin, Node.js, Objective-C, OCaml, PHP, Postman CLI, PowerShell, Python, R, Ruby, Rust, Shell and Swift, with their variants.

## Debugger

- Enable debugging in your debug settings : the requests of the API Testing page then run in the **sandbox for
  debugging** of their environment (one per environment and group of separate sandboxes : one sandbox, one runner),
  whose runner listens for an inspector. Attach Chrome DevTools (`chrome://inspect`) and stop on breakpoints or on
  `debugger;` in your code. A request waiting at a breakpoint is not timed out for an hour.
- It works for JavaScript and TypeScript on Node.js and on Bun (Bun's web inspector, or the Bun extension of VS Code),
  for code that runs in a sandbox. The other requests keep using the usual sandboxes.
- The port of the inspector is open on the server itself only (127.0.0.1) : reach it through an SSH tunnel. The debug
  settings show the command of every sandbox for debugging of every server, for example
  `ssh -L 9229:localhost:41237 root@your-server`, after which `chrome://inspect` finds it on `localhost:9229`.

## Code finder

- Search a word in all your code at once: custom APIs, hooks, events, schedulers, migrations, utility classes, schemas, secrets and more, and open the result to edit it.
- Learn more [Code finder](https://docs.apimaker.dev/v4/docs/features/team-work.html#code-finder).

## Your own editor

- `localClient.js` in your Git repository syncs your files with API Maker both ways.
- Generate a sync token in your user profile and set it in `local-client.config.js`.
- `npm install` once : the packages your code uses and the declarations of Node.js (`@types/node`), which `tsconfig.json` names for VS Code and WebStorm.
- `npm run start` keeps the folder in sync, `npm run test` runs the test cases of the account from the terminal and writes their code coverage to `coverage/lcov.info` for VS Code and WebStorm. Learn more [Test cases](https://docs.apimaker.dev/v4/docs/test-cases/test-cases.html).
- While it is connected, API Maker also scans the account on its own and keeps `src/api_security_report/` up to date on your disk and in git, so an AI assistant working in the folder reads a fresh report. Learn more [APIs Security Report & Actions](https://docs.apimaker.dev/v4/docs/apis-security/api-security-report.html).
- An AI agent (Codex, Claude Code, Cursor, Copilot) working in the folder reads `AGENTS.md` at its root : every commit writes the guide of API Maker into it. Learn more [AGENTS.md in your repository](https://docs.apimaker.dev/v4/docs/ai/llms.html#agents-md).

```javascript
module.exports = () => {
    return {
        webSocketURL: 'wss://ws.example.com', // WebSocket URL of your API Maker
        syncToken: '...', // generate it in your user profile
        adminUserPath: 'admin',
    };
};
```