the independent audit for AI-generated codean independent check of code an AI assistant helped you writethe independent audit for AI-generated code

Check your code for bugs — here, or right inside your vibe-coding assistant.Check your code for problems — right here, or right inside the AI assistant you built it with.Check your code for bugs — here, or inside your vibe-coding assistant.

What you get →

Paste a repo or a .zip here, or let the assistant that wrote the code run the check over MCP. Either way you get a clear answer: ship it, or fix these first. Every risk comes with evidence and a fix.Paste in the address of your project’s code on GitHub (called a “repo”), or upload it here as a .zip file. Or, let the AI assistant that wrote your code run the check itself, through its connector (called MCP). Either way, you get a clear answer: ship it, or fix these things first. Every problem comes with proof and a fix.Paste a repo or a .zip here, or let your assistant run the check over MCP. Either way: ship it, or fix these first. Every risk comes with evidence and a fix.

We publish every result — zero false alarms across 25 clean, mature libraries.We publish every result — zero wrong warnings out of 25 solid, well-known code libraries we tested.We publish every result — zero false alarms across 25 clean, mature libraries.

Loop Nothing of your code is sent to nittim — not a file, not a line, not a finding. Your assistant reads the checklist and your code where it already works. If you choose to, it can share anonymised counts from a run, and nothing else.None of your code is sent to nittim — no files, no lines, not even the text of what it found. Your own AI assistant reads the checklist and your code right where it already works, the same place it always runs. You can choose to share anonymised counts from a run — how many passes, how many findings by category — and that is all that would ever go.Nothing of your code is sent to nittim. Your assistant runs it where it already works. Anonymised counts only, and only if you choose.
Scan File contents leave your machine and are read in nittim's server memory. No model reads them and no verdict is written. What is kept is your report — including the line each finding points at, unless your organisation turns that off.Your files do leave your machine — they are read in nittim's server memory. No AI reads them, and no verdict is written about them. What we keep is your report, and that includes the exact line each finding points at. Your organisation can switch that off in its settings, and then we keep the location but not the line.Files leave your machine and are read in nittim's server memory. No model, no verdict. Kept: your report, with the line each finding points at — off by setting.
Audit The digest goes to Anthropic over the API, on nittim's key, and Anthropic keeps API inputs and outputs for up to 30 days. Bring your own key and it goes to your account instead.The summary goes to Anthropic (the company behind Claude) over its API, on nittim's account. Anthropic keeps what goes in and comes out for up to 30 days. Use your own Anthropic key and it goes to your own account instead.The digest goes to Anthropic on nittim's key, kept up to 30 days. Bring your own key and it goes to your account.

Free scan — no sign-in, no card; finds leaked secrets and known-vulnerable packagesno sign-in, no card; finds passwords left in your code and ready-made packages with known security bugsno sign-in, no card — finds secrets and vulnerable packagesAudit — your first Audit is free. After that, about $5. Usually within 15 minutes*Report library See how real repos score — 86 open-source reports, free.See how real projects score — 86 free reports on real, publicly available code.See 86 free reports on real repos. Browse the libraryBrowse the reportsBrowse the library

The digest goes to Anthropic over the API, on nittim's key, and Anthropic keeps API inputs and outputs for up to 30 days. Bring your own key and it goes to your account instead.The summary goes to Anthropic (the company behind Claude) over its API, on nittim's account. Anthropic keeps what goes in and comes out for up to 30 days. Use your own Anthropic key and it goes to your own account instead.The digest goes to Anthropic on nittim's key, kept up to 30 days. Bring your own key and it goes to your account.

* Most reports land within 15 minutes. Worst case, 24 hours.

See one real finding →See one real problem →See one real finding →

One finding, exactly as the report shows itOne real problem, shown exactly as the report shows itOne finding, exactly as the report shows it

GitHub Actions script injection via release event fields in news-update workflows

HighSecurity.github/workflows/update-news-www.yml:19Small (hours)Quick (a few hours)Small (hours)

EvidenceWhat we foundEvidence: .github/workflows/update-news-www.yml:19and .github/workflows/update-news-www-legacy.yml:19 embed ${{ github.event.release.published_at }} and ${{ github.event.release.tag_name }} directly into a shell `sed -i` command (IaC scan: gha-script-injection).
Business impactWhy it mattersImpact: Untrusted-looking event input interpolated into a shell command can allow command injection into the CI runner, potentially compromising build secrets or the project's own web content pipeline — a supply-chain integrity risk distinct from the app's intentional vulnerabilities.
Root causeWhy it happensCause: Direct interpolation of GitHub event context into a run: shell step instead of passing values via environment variables.
Recommended fixHow to fix itFix: Assign the event fields to env: variables and reference them as "$TAG_NAME"/"$PUBLISHED_AT" inside the script, or validate/escape them; never inline ${{ github.event.* }} into shell.

RemediationHow to fix itRemediationSmall (hours)Quick (a few hours)Small (hours)

From the report on juice-shop/juice-shop. Read the whole report →Read the full report →Read the whole report →

86 open-source reports, free. 86 free reports on real, publicly available code. 86 open-source reports, free. Browse the libraryBrowse the reportsBrowse the library

How it works

Point it at a repoPoint it at your project's codePoint it at a repo

A public URL, a connected private repo, or a zip. No account needed for a free scan. File contents leave your machine and are read in nittim's server memory. No model reads them and no verdict is written. What is kept is your report — including the line each finding points at, unless your organisation turns that off.A public GitHub address, a connected private project (called a "repo"), or a .zip file you upload. No account needed for a free scan. Your files do leave your machine — they are read in nittim's server memory. No AI reads them, and no verdict is written about them. What we keep is your report, and that includes the exact line each finding points at. Your organisation can switch that off in its settings, and then we keep the location but not the line.A public URL, a repo, or a zip. Free scans need no account. Files leave your machine and are read in nittim's server memory. No model, no verdict. Kept: your report, with the line each finding points at — off by setting.

We read what we can, honestlyWe read as much of your code as we can, and say so honestlyWe read what we can, honestly

Coverage is stated up front, in the report itself — not buried in a footnote.We tell you exactly how much of your code we checked, right in the report — not buried in a footnote.Coverage is stated up front, in the report — not a footnote.

Get scored, sourced findingsGet a scored list of problems, each backed by evidenceGet scored, sourced findings

Severity, evidence, and a fix for each one — or read everything with Full Audit. The digest goes to Anthropic over the API, on nittim's key, and Anthropic keeps API inputs and outputs for up to 30 days. Bring your own key and it goes to your account instead.How serious each one is, the proof, and how to fix it — or have every file checked with Full Audit. The summary goes to Anthropic (the company behind Claude) over its API, on nittim's account. Anthropic keeps what goes in and comes out for up to 30 days. Use your own Anthropic key and it goes to your own account instead.Severity, evidence, a fix for each — or Full Audit reads everything. The digest goes to Anthropic on nittim's key, kept up to 30 days. Bring your own key and it goes to your account.

Why a green report means somethingWhy a good result actually means somethingWhy a green report means something

The author never grades the paper. An independent audit scores your code against a fixed framework — green means something.The AI that wrote your code never grades its own work. A separate, independent check scores your code against the same fixed rules every time — so a green result actually means something.The author never grades the paper. An independent audit scores your code against one fixed framework.

A floor the model can't sink below. Committed secrets and known CVEs are found by deterministic scanners, not by a model's mood.There's a floor no model can talk its way under. Passwords or keys left in your code, and known security bugs in your dependencies, are caught by fixed, rule-based scanners — never by an AI's opinion.A floor the model can't sink below. Deterministic scanners catch committed secrets and known CVEs, not moods.

Fix, recheck, repeat — without babysitting. Findings go back to your assistant, it fixes them, and the audit runs again. You review a closed loop, not a to-do list.Fix it, check it again, repeat — without you babysitting every step. Findings go back to your AI assistant, it fixes them, and the check runs again on its own. You look at a finished loop, not a growing list of things to do.Fix, recheck, repeat — no babysitting. Findings go to your assistant, it fixes them, the audit reruns. Review a closed loop, not a to-do list.

Every claim comes with evidence. The exact file and line. Dispute one and you get the quote back, not “trust me.”Every finding comes with proof. The exact file and line it's pointing at. Dispute one and you get the exact quote back — not just our word for it.Every claim comes with evidence. File and line. Dispute one, get the quote back — not “trust me.”

Production-safe is a state, not a feeling. 13 categories, six scores, one verdict — ship it or don't, with reasons.Whether your code is safe to ship is a fact, not a feeling. 13 categories of checks become six scores and one final verdict — a clear yes or no, with the reasons why.Production-safe is a state, not a feeling. 13 categories, six scores, one verdict — ship or don't, with reasons.

See the full framework →

The Loop — free, and none of your code is sentThe Loop — free, and none of your code is sent to usThe Loop — free, no code sent

A review checklist your own assistant runs, where your code already is.A checklist of things to look for that your own AI assistant works through, right where your code already lives.A checklist your own assistant runs, where your code already is.

Nothing of your code is sent to nittim — not a file, not a line, not a finding. Your assistant reads the checklist and your code where it already works. If you choose to, it can share anonymised counts from a run, and nothing else.None of your code is sent to nittim — no files, no lines, not even the text of what it found. Your own AI assistant reads the checklist and your code right where it already works, the same place it always runs. You can choose to share anonymised counts from a run — how many passes, how many findings by category — and that is all that would ever go.Nothing of your code is sent to nittim. Your assistant runs it where it already works. Anonymised counts only, and only if you choose.

Run the Loop →See the counts other runs sharedSee the counts other people's Loop runs chose to shareSee the counts other runs shared

In the machine’s own wordsWhat the check actually looks atIn the machine’s own words

Read it:

Let your AI assistant do itLet the AI assistant that wrote your code do itLet your AI assistant do it

Want free looks, forever? Look in your assistant — no key, no account. Secrets and known CVEs, and your teammates get it too once it's in CLAUDE.md.Want free checks, forever? Ask the AI assistant you code with — no password, no account. It checks for exposed passwords and known security bugs in your ready-made packages, and your teammates get it too once it's saved in your project's CLAUDE.md file.Free, forever. Ask your assistant — no key, no account. Checks secrets and known CVEs; save to CLAUDE.md and teammates get it too.

Paste this to your assistant:Paste this to your AI assistant:Paste this to your assistant:

I’d like to connect nittim’s code scanner to this project. nittim is a code-audit service at nittim.com; what it does with code it reads is at nittim.com/trust.

So you don’t have to take a vendor’s word for it: the scan works by sending file contents to nittim.com. I’ve read their trust page and decided that’s acceptable for this repo — that call is mine, not yours.

It runs as an MCP server, so this adds one entry to my client’s config — not to my repo — and my client still asks me before a tool call. With no key it can read and price: scan_source, list_modules and estimate_audit, and none of it costs anything.

Please connect it:
claude mcp add --transport http nittim https://nittim.com/api/mcp

Then, before you scan this folder for committed secrets and known vulnerable dependencies, show me the list of files you would send and wait for my yes. Leave out anything holding customer data. I have no nittim key, so skip anything that costs money.

Free, no account, no nittim credits — the same deterministic scan as a free scan on the web, no AI, read in memory — it keeps the findings, never the files. Commit it to your project's CLAUDE.md and every teammate's assistant reaches for it automatically — no key in the file, because there is none to leak. Get the CLAUDE.md block →Free, no account needed, no nittim credits spent — the same rule-based check as a free scan on the web. No AI reads your code here, and it's only held in memory for a moment — nittim keeps the list of problems it found, never your actual files. Save it to your project's CLAUDE.md file (a notes file your AI assistant reads automatically) and every teammate's assistant picks it up too — no password saved in the file, because there is none to leak. Get the CLAUDE.md block →Free — no account, no nittim credits. Same deterministic scan as the free web scan: no AI, read in memory, keeps findings, never files. Commit it to CLAUDE.md and every teammate's assistant picks it up automatically — no key in the file, because none exists to leak. Get the CLAUDE.md block →

Want the deeper, 13-category self-review instead — on your own model, nothing sent to nittim at all? Also available as an MCP prompt — nittim-selfcheck — the moment you're connected, or run it directly: /selfcheckWant a deeper, 13-category self-check instead — using your own AI, with nothing sent to nittim at all? It's also available as a ready-made prompt for your connector — nittim-selfcheck — the moment you're connected, or run it directly: /selfcheckWant the deeper, 13-category self-review — on your own model, nothing sent to nittim? Run it as the MCP prompt nittim-selfcheck once connected, or directly: /selfcheck

What we checkWhat we check forWhat we check

14 things that decide whether your software survives real users — not just syntax.14 things that decide whether your app survives real users — not just whether the code runs.14 things that decide whether your software survives real users — not just syntax.

See every check

Linters check syntax. nittim reasons about whether your software survives contact with production. The exact module set is selected per repository from its file tree; every report shows a “Modules run” strip naming exactly what fired.Simple code-style tools only check that your code is written correctly. nittimreasons about whether your app will actually hold up once real people use it. The exact set of checks is chosen for your project from its own files; every report shows a “Modules run” strip naming exactly which checks ran.Linters check syntax. nittim reasons about whether your software survives production. The module set is chosen per repo from its file tree; every report's “Modules run” strip names exactly what fired.

Six scores — Executive, Production Readiness, Security, Privacy, Architecture, and IP Protection — and one verdict: Production Ready · Production Ready with Conditions · High Risk · Not Safe for Production. The verdict is held to the hard evidence found in your code — a confident write-up cannot lift it.Six scores — Executive, Production Readiness, Security, Privacy, Architecture, and IP Protection — and one final verdict: Production Ready · Production Ready with Conditions · High Risk · Not Safe for Production. The verdict depends only on real evidence found in your code — confident-sounding writing can't raise it.Six scores — Executive, Production Readiness, Security, Privacy, Architecture, IP Protection — and one verdict: Production Ready · Production Ready with Conditions · High Risk · Not Safe for Production. The verdict rests on hard evidence in your code — confident writing can't lift it.

Can someone break in?

Security · counts as Core toward the score

We look for the vulnerabilities that turn a data breach into a headline — injection flaws, broken authentication, exposed secrets, and gaps in how your APIs and infrastructure protect themselves. Every finding points to the exact file and line, with a fix.

module security · priority tier Core · Claude-reasoned · findings land under Security

Are you handling people's data properly?

Privacy & Compliance · counts as Core toward the score

We check how your app collects, stores, and hands off personal data — consent, data governance, audit trails, and readiness for the regulations that actually apply to you, including GDPR, CCPA, HIPAA, PCI DSS, and SOC 2.

module privacy · priority tier Core · Claude-reasoned · findings land under Privacy & Compliance

What happens when something goes wrong?

Reliability & Resilience · counts as Core toward the score

We look at what happens when something goes wrong — a crash, a dropped connection, a bad deploy — and whether your app recovers gracefully or takes your users down with it. Backups, failover, and fault tolerance all fall here.

module reliability · priority tier Core · Claude-reasoned · findings land under Reliability & Resilience

Can you build on this next month?

Code Quality & Architecture · counts as Important toward the score

We read your codebase the way a senior engineer would on day one: is it organized, is it readable, and how much will the next feature cost to build on top of it. This is where technical debt gets named.

module code_quality · priority tier Important · Claude-reasoned · findings land under Code Quality & Architecture

Did the AI fake anything?

AI / Vibe Coding Risk · counts as Important toward the score

AI-generated code has its own failure modes — confident-looking placeholder logic, hallucinated APIs, copy-pasted duplication, and edge cases nobody thought to handle because nobody wrote the code by hand. We look specifically for these.

module ai_risk · priority tier Important · Claude-reasoned · findings land under AI / Vibe Coding Risk

Will it slow down when people show up?

Performance & Scalability · counts as Important toward the score

We look at what slows your app down under real load — inefficient queries, missing caching, wasted memory, and anything that gets more expensive as you grow.

module performance · priority tier Important · Claude-reasoned · findings land under Performance & Scalability

Can you deploy it safely, again and again?

Infrastructure & DevOps · counts as Important toward the score

We check the machinery that gets your code into production and keeps it there — your CI/CD pipeline, container and infrastructure setup, environment separation, and how secrets are managed through their whole lifecycle.

module devops · priority tier Important · Claude-reasoned · findings land under Infrastructure & DevOps

Could your data get quietly corrupted?

Data Layer · counts as Important toward the score

We look at your data layer for the mistakes that are hardest to undo — unsafe migrations, missing constraints, unencrypted sensitive fields, and transaction handling that can silently corrupt data.

module data · priority tier Important · Claude-reasoned · findings land under Data Layer

Can you run a business on it?

Business & Product Risk · counts as Supporting toward the score

We step back and ask the practical questions a founder or investor would: is this ready to run a real business on, what does it actually cost to keep alive, and where are you locked into a vendor or a license you didn't mean to take on.

module business · priority tier Supporting · Claude-reasoned · findings land under Business & Product Risk

Is it painful to work in?

Developer Experience · counts as Supporting toward the score

We check how easy your own repository is to work in — local setup, build reproducibility, onboarding a new engineer, and the release process. A repo that's painful to develop in slows down everything else.

module devex · priority tier Supporting · Claude-reasoned · findings land under Developer Experience

Can everyone use it?

Accessibility & UX · counts as Supporting toward the score

We check whether your app is usable by everyone — screen-reader and keyboard support, responsive layouts, clear error messaging, and basic internationalization and browser-compatibility gaps.

module accessibility · priority tier Supporting · Claude-reasoned · findings land under Accessibility & UX

Would you notice if it broke?

Observability · counts as Supporting toward the score

We check whether you'd actually notice if something broke — logging, metrics, tracing, and alerting that gets a human to the right place before your users notice first.

module observability · priority tier Supporting · Claude-reasoned · findings land under Observability

Will it still be maintainable in a year?

Maintainability Forecast · counts as Specialized toward the score

We take a forward-looking view: how much of this codebase depends on one person's memory, how expensive a future rewrite would be, and whether this is something you can keep maintaining a year from now.

module maintainability · priority tier Specialized · Claude-reasoned · findings land under Maintainability Forecast

Are your best ideas showing?

IP & Novelty Exposure · counts as Specialized toward the score

We flag the genuinely novel ideas in your codebase — algorithms, architectures, or methods worth protecting — and check two separate ways they can leak: through a public repository, and through public-facing copy (README, docs, marketing) that spells out how something works rather than just what it does. This is an independent signal and never affects your production verdict.

module ip_exposure · priority tier Specialized · Claude-reasoned · findings land under IP & Novelty Exposure

How often we’re wrongHow often we get it wrongHow often we’re wrong

We measure it and publish it — with the confidence interval and the caveats attached. 0 false alarms on 25 clean libraries (95% CI 0–13.8%).

Read the benchmark

Measured, not claimedMeasured, not just claimedMeasured, not claimed

0 of 25
false criticals on clean, mature libraries — both tierswrong "critical" warnings on clean, well-known code libraries — both tiersfalse criticals — clean, mature libraries, both tiers

11 of 11
intentionally-vulnerable apps verdicted unsafeapps built with known security holes that we correctly flagged as unsafeintentionally-vulnerable apps verdicted unsafe

0 of 20
secret false-criticals on real deployed appswrong password/key warnings on real, live appssecret false-criticals — real, deployed apps

16 of 20
mature deployed apps passed green, Deep tierestablished, live apps that passed with a green result, Deep tiermature deployed apps passed green, Deep tier

Small corpora, honest caveats — every number ships with its method and confidence interval.Small test sets, honest caveats — every number comes with how we measured it and how sure we are.Small corpora, honest caveats — every number ships with its method and confidence interval.

0 of 25 false criticals → 95% CI 0–13.8% (Clopper-Pearson). Verdict-level recall 100% (11 of 11); 91.7% under strict pre-registration. The libraries corpus is IN-SAMPLE — four precision rules were written against its failures — so read it beside the 12-library held-out number (1 of 12 secret FCR, pre-registered before it ran), never alone. The judge shares the Opus family; only the separate MCP cross-check is cross-vendor. Every not-green deployed-app verdict was adjudicated over-escalated on dependency drift; root causes fixed, re-run outstanding.

A human vibe-code audit runs $500–$3,000 and takes days to weeks. nittim deep-verifies a repo in minutes — with the evidence attached.Having a person review AI-generated code by hand costs $500–$3,000 and takes days to weeks. nittim checks your project in minutes — with the proof attached.A human audit runs $500–$3,000 and takes days to weeks. nittim deep-verifies a repo in minutes — evidence included.

Is my code safe with you?Is my code safe with nittim?Is my code safe with you?

Start without showing us a single line of your code. Hand over more only when you decide to.You can start without showing us a single line of your code. You choose to share more, if and when you decide to.Start without showing a single line of code. Share more only when you decide to.

What we store

You shouldn't have to decide whether to trust nittim before you get anything out of it. Start at the top.You shouldn't have to decide whether to trust nittim before you get anything out of it. Start at the top level, where nothing is shared yet.You shouldn't have to trust nittim before you get anything from it. Start at the top.

0 · Your assistant, our rubric

Nothing reaches nittim. No independent judge either.

/selfcheck is the public shape of our 13 categories. Your assistant reviews your code against it, wherever your assistant already runs. You give us nothing. The model that wrote your code is the one grading it, so anything it did not think of the first time it will not think of now — catching that is what an independent judge is for, and it is the one thing we sell. That trade is yours to make./selfcheck is the public version of our 13 categories. Your own AI assistant checks your code against it, wherever your assistant already runs. You give us nothing at all. But the AI that wrote your code is the same one grading it here, so anything it missed the first time, it will likely miss again — catching that blind spot is exactly what an independent, different judge is for, and that is the one thing we sell. That trade is yours to make.Run /selfcheck’s 13 categories with your own assistant — you give us nothing. It wrote the code, so it may repeat its own blind spots; an independent judge catches those, and that’s what we sell.

1 · Our report library

Nothing of yours leaves your machine.

/library holds real free scans of well-known public code — large applications, mature libraries, training apps built to be broken. Read one before nittim has seen a line of yours. Nothing on this rung asks you to take anything on faith./library holds real free scans of well-known public code — large applications, mature code libraries, training apps built with problems on purpose. Read one before nittim has ever seen a line of your own code. Nothing on this rung asks you to take anything on faith.Read real scans of well-known public code in /library before nittim sees a line of yours. Nothing to take on faith.

2 · Your repo, free scan

Read in memory, never written down.

There is no AI anywhere in the free scan. Two deterministic scanners read the files, and the report is built from what they found. A test in our build fails if source text ever reaches the database, so this is a property of the code rather than a promise about it.There is no AI anywhere in the free scan. Two fixed, rule-based checks read your files — one for passwords or keys left in your code, one for known security bugs in the ready-made packages your project uses — and the report is built from what they find. A test in our own build actually fails if any of your code's text ever reaches our database, so this is built into the code itself, not just a promise.No AI in the free scan. Two deterministic scanners read the files and build the report. A test fails the build if source text reaches the database — a property of the code, not a promise.

3 · AI audit on your own key

The reasoning runs on your Anthropic account.

BYOK Pro, over the API, MCP or the GitHub Action: the model call goes to your organization, on your key, under the terms you agreed with your vendor. nittim's own model account never sees your code. You don't have to believe us — the tokens show up on your Anthropic bill.BYOK Pro, over the API, MCP or the GitHub Action: the AI call goes straight to your own organization, using your own key, under the agreement you already have with Anthropic. nittim's own model account never sees your code. You don't have to take our word for it — the usage shows up right on your own Anthropic bill.BYOK Pro — API, MCP, or GitHub Action: the call runs on your key, under your vendor terms. nittim's model account never sees your code — check your own Anthropic bill.

4 · AI audit, on our key

Your code, in memory, plus our model vendor.

Held in memory for the length of the audit, never trained on, discarded when it finishes. This is the one rung that asks you to take nittim's word for something — which is why it is the last one and not the first.Held in memory only for as long as the check takes, never used to train any model, and thrown away when it finishes. This is the one rung that asks you to take nittim's word for something — which is exactly why it's listed last, not first.Held in memory for the audit, never trained on, discarded after. The one rung that asks you to take nittim's word for it — last on purpose.

5 · Your own infrastructure

Nothing leaves your cloud at all.

Built, and both halves have run end to end: they run inside your own account, so no source, no finding and no repository name reaches nittim at all. It is not self-serve — we set it up with you, on request. One honest gap: the container images are not signed yet, so you can verify what we hand you by its published hash, not by a signature.Built, and we have run both halves all the way through: they run inside your own cloud account, so no code, no finding and no project name ever reaches nittim at all. You can’t switch it on yourself — we set it up with you, on request. One honest gap: the software images aren’t digitally signed yet, so you can check what we hand you against the published fingerprint, but not against a signature.Built, both halves ran end to end, and it runs in your account — no source, finding or repo name reaches nittim. Not self-serve: we set it up with you on request. Images aren’t signed yet — verify by published hash.

Stored: Audit report — findings, scores, verdict, repository name.The audit report — problems found, scores, verdict, and your project's name.Audit report — findings, scores, verdict, repository name.
Not stored: Source code — fetched into server memory during analysis, discarded when the pipeline finishes. Exception: a finding's evidence includes the offending lines it points at.Your source code — loaded briefly into server memory while it's checked, then deleted once the check finishes. Exception: a problem's evidence includes the exact lines it points to.Source code — fetched into server memory during analysis, discarded when the pipeline finishes. Exception: finding evidence includes the lines it points to.
Not stored: GitHub tokens — used once, discarded. App installation tokens expire within the hour; nittim records only the installation id.GitHub access tokens (temporary passwords for reading your code) — used once, then deleted. They expire within the hour anyway; nittim keeps only an installation id number, not the token itself.GitHub tokens — used once, discarded. Installation tokens expire within the hour; nittim keeps only the installation id.
Read-only: The GitHub App holds exactly two permissions — repository contents: read-only, metadata: read-only — and subscribes to no events. nittim can never modify your code.The GitHub connector nittim installs can only read — your project's contents and basic info, nothing more — and it isn't notified of anything that happens in your project. nittim can never change your code.GitHub App: exactly two permissions — contents and metadata, both read-only — no events. nittim can never modify your code.

What it costs

Scanning is free, forever. A GitHub or Google account gets one covered Audit. After that, $29 buys two. The digest goes to Anthropic on nittim's key, kept up to 30 days. Bring your own key and it goes to your account.

Buy credits

nittim never bills a flat rate for tokens it doesn't control. An AI audit is prepaid credits, your own Anthropic key, or your own cloud — your choice, never a surprise.nittim never charges a flat fee for AI usage it doesn't control. You pay with prepaid credits, your own Anthropic (Claude) key, or your own cloud — your choice, never a surprise bill.nittim never bills flat rate for tokens it doesn't control — prepaid credits, your own Anthropic key, or your own cloud, your choice, never a surprise.

Free: Deterministic secret + dependency-CVE scan, any public or connected repo, forever. No card, no sign-in. One covered Audit run per account (GitHub or Google sign-in).A rule-based check for exposed passwords and known security bugs in your ready-made packages, on any public or connected project, forever. No card, no sign-in needed. One covered Audit run per account (sign in with GitHub or Google).Deterministic secret + dependency-CVE scan — any public or connected repo, forever. No card, no sign-in. One covered Audit run per account (GitHub or Google).
Credits: 1 credit = $1. An AI audit is 5.14 credits; a single module via API/MCP is 5.03. Packs: $29 → 5 · $74 → 17 · $189 → 52 · $479 → 157 audits. Credits never expire · unused credits refundable within 30 days.1 credit = $1. An AI audit is 5.14 credits; running a single check on your own is 5.03. Packs: $29 → 5 · $74 → 17 · $189 → 52 · $479 → 157 audits. Credits never expire · unused credits refundable within 30 days.1 credit = $1. An AI audit costs 5.14 credits; a single module via API/MCP costs 5.03. Packs: $29 → 5 · $74 → 17 · $189 → 52 · $479 → 157 audits. Credits never expire · unused credits refundable within 30 days.
BYOK Pro: $49/mo is the pipeline, not the tokens — bring your own Anthropic key; a 100-credit monthly allowance covers ~50 single-pass audits at 2 credits each.$49/mo pays for the pipeline that runs the check, not for the AI usage itself — you bring your own Anthropic (Claude) key. A 100-credit monthly allowance covers about 50 single-pass audits at 2 credits each.$49/mo pays for the pipeline, not tokens — bring your own Anthropic key. A 100-credit monthly allowance covers ~50 single-pass audits at 2 credits each.
Enterprise: from $18k/yr — seat bands, unlimited repos, single sign-on, SARIF, policy-as-code, an append-only audit log. Claude via Bedrock in your AWS, or your own Anthropic org. Orgs share one audit portfolio and one bill. Talk to us →from $18k/yr — priced per team size, unlimited projects, single sign-on, standard report formats, rules your company sets, and a permanent record of every audit. Runs on Claude inside your own AWS or Anthropic account. Whole organizations share one audit history and one bill. Talk to us →from $18k/yr — seat bands, unlimited repos, SSO, SARIF, policy-as-code, append-only audit log. Runs on Claude via Bedrock in your AWS, or your own Anthropic org. Orgs share one audit portfolio and one bill. Talk to us →