RabbinatixDocs
Sign inGet started

Map your systems

Security checks

Find the usual API security mistakes in your design and your code: an API that changes data without sign-in, a password in a response, a token in the URL.

Open Security checks in the app

What the checks find

Rabbinatix checks every API you design for the usual security mistakes. The checks are fixed rules, the same every time: no AI model runs on our side. Open Security checks in the sidebar to see them all. The red number next to it counts the errors still open.

CheckFindsSeverity
Changes data without sign-inA POST, PUT, PATCH or DELETE with Authentication None, or sign-in not requiredError
Reads data without sign-inA GET with no sign-in that isn’t marked public on purposeWarning
Weaker sign-in than the rest of the systemAn API key or basic auth where most of the system uses bearer tokens or OAuth 2Warning
Basic authBasic auth, which sends the password with every requestWarning
Secret in the URLA query or path parameter named like token, password, apiKey, secret or sessionError
Secret in a responseA response field like password, passwordHash, cvv, cardNumber, pin or ssnError
Personal dataResponse fields like email, phone, dateOfBirth, address or ibanNote
No 401 or 403 responseAn API that needs sign-in but says nothing about what happens without itNote
Sign-in with no slow-downSign-in, password reset and code checks without a 429 (too many attempts) responseWarning
Request can set roles or ownersA request body with role, isAdmin, permissions, ownerId, plan or tenantIdWarning
Records by idAn {id} in the path, signed in, with no scopesNote
List without a limitA GET that returns a list with no limit, page or cursor parameterNote
Real-looking secret in an exampleA real-looking key or token in examples, test data or a test case’s inputError

Checks the rules can’t be sure about carry a Check this label: they ask you to look, they never say the design is wrong. The systems you build are checked against every rule. Outside APIs and other workspaces’ public APIs are only checked for what you send them.

Where you see them

  • Security checks in the sidebar: every finding in the project. Filter by system and severity; the Accepted list keeps the risks you accepted.
  • Dashboard: the Security card counts the open errors and warnings and opens the list.
  • A system’s page: the Security tab lists the findings on its APIs, and what the code scan found in its code.
  • An API: open it from the map or a system; the Security checks section under Responses lists its findings.
  • While you edit an API: a note appears under the field that causes a finding, for example under Authentication when a POST has None, or under a response body that has a password field.
  • AI drafts: when your assistant drafts a change that adds a security error or warning, the batch shows it next to the other things to look at twice. It never stops you accepting the batch.

Fix a finding

Many findings come with a fix. Press Fix to see the change first (for example, Authentication set to the system’s usual sign-in, a 429 response added, or a limit parameter added), then Apply fix to save it to the API. It is saved like any edit you make, so it shows in the API’s history and in Activity. You need permission to edit APIs.

Your assistant can do the same with the security action: it explains each finding in plain words, checks the fix, and drafts one batch per system for you to review. See the AI assistant reference.

Accept a risk

Some findings are fine as they are: an internal API behind a private network, or a lookup that really is public. Press Accept risk and say why. For an API that reads without sign-in on purpose, press Public on purpose instead. The finding moves to the Accepted list with your reason, your name and the date, and the Activity log records it. Open again puts it back.

Accepting needs the Security checks permission. Owners, admins and developers have it by default; a viewer can read the findings but not accept them.

Code scan

The design checks look at the map. The code scan looks at your code, in two ways that work together: rabbinatix scan finds what fixed rules can find (secrets, risky code, vulnerable dependencies) on every change, and your assistant reads the repository on your machine for what needs understanding, such as a missing access check or a logic flaw (below). Both report to Rabbinatix. Nothing is uploaded except the findings: a short snippet (at most five lines, with anything that looks like a secret masked), the file and line, and the branch and code version.

  1. In your editor, ask your assistant to scan the code with Rabbinatix. AI prompts → Scan for what rules can’t find at the top of Security checks copies the words. The assistant runs rabbinatix scan first and leaves what it finds to it.
  2. The findings appear on the Code scan tab, each with its severity, file and line, branch, the system it belongs to and when it was first and last seen.
  3. Triage them: Apply fix for the ones your assistant should fix, Dismiss with a reason (a false alarm, an accepted risk, or won’t fix), or Create tickets. Select rows, or all that match the filter, to do several at once.
  4. Copy AI prompts → Apply the fixes marked “Apply fix” into your assistant. It fixes them one at a time, runs your tests, and tells Rabbinatix which code version fixed each one: they show as Fixed.
  5. The next scan of that branch confirms it: a fixed finding that isn’t found again becomes Resolved; one that is found again goes back to Apply fix. You can also press Confirm resolved.

A dismissed finding stays dismissed: the next scan doesn’t bring it back. To match code to systems, set the Code repository (and folder) in a system’s Settings tab.

NoteThe assistant needs a key with Report findings turned on. Keys made before the code scan existed have it off until someone turns it on.

From your CI: rabbinatix scan

The assistant understands the code, so it finds things like a missing access check. For the checks that follow fixed rules, on every change, run rabbinatix scan in your CI (or on your machine). It reads the repository where it runs and finds:

  • secrets in known formats (AWS, GitHub, Stripe, Slack, private keys and more), and passwords or keys written into the code;
  • risky code: text run as code, shell commands and SQL built from variables, TLS checks turned off, HTML set from variables, weak hashes, unsafe deserialisation, JWT mistakes;
  • dependencies with known vulnerabilities, from your lock files (npm, Python, Go, Ruby, Rust, PHP, .NET and Gradle), checked against OSV: only package names and versions are sent there;
  • whatever Semgrep and Gitleaks find, when they are installed where it runs.
npx -y rabbinatix scan --report --fail-on high

With --report the findings go to the Code scan tab, next to the assistant’s, and you triage them the same way. It needs an API token with the scan scope (Integrations → API tokens; making one needs the Security checks permission) in RABBINATIX_TOKEN, and the API address in RABBINATIX_API. --fail-on fails the build when a finding is that severe or worse; ones you dismissed in Rabbinatix don’t count. Add rabbinatix-ignore in a comment on a line to skip it there.

Each kind of scan confirms only its own findings: a scan by rabbinatix scan marks its fixed findings Resolved, and leaves the assistant’s for the assistant’s next scan.