Who audited it, which version of the code, how severe the findings were, and whether each one got fixed. Those four things are what a non-coder can actually use from a crypto audit report — and they are also the limit of what an audit is for. A report says that one security firm, at one point in time, read one version of a smart contract, listed what it found, and recorded what the team did about it. It does not say the project is safe. Auditors say so themselves: ChainSecurity's guide to reading their reports puts it as "The promise of an audit is not bug-free code."
So the "Audited" badge on a project's banner carries almost no information by itself. The few minutes worth spending go into checking those four columns. Below, I walk through them on a report anyone can open, and end with what you still can't see once you've done it.
This expands on what you can and can't check before a launch, a checklist that never gave audits their own row.
01Four columns hiding inside "audited"
Audit firms format reports differently. Some are long PDFs, some are web pages. The skeleton is similar, though: a summary up front, then the scope, the list of findings, and what happened to each one. ChainSecurity's advice is to read the executive summary first. The Hacken report in section 06 is a good example: its summary already tallies the findings by severity.
| Column | Where it sits | What you can do without reading code |
|---|---|---|
| Who audited it | Cover page; the site hosting the report | Search the auditor's own website for the project and see whether the report is there |
| Scope and version | The Scope section | Look for a commit hash or contract address, and for files that were left out |
| Severity | Summary counts | Count the Critical and High findings |
| Status of each finding | The Status field on every item | Check that every Critical and High is marked fixed, and that the auditor confirmed the fix |
Of the four, status is the one I care about most. A score or a badge is a summary. Status is item-by-item fact.
02Who did the audit, and where the report lives
ChainSecurity says the auditor should be well known, with several years of auditing behind them. Fair enough, but most of us have no way to rank audit firms.
The useful habit is blunter: ignore screenshots, PDFs and links handed to you by the project, and go find the report on the auditor's own site. If it's real, it lives on the auditor's domain. The example report in section 06 sits under the audits directory on hacken.io — that's what a good answer looks like.
Why bother? CertiK wrote a whole post about it in January 2024: phishing sites and projects were falsely claiming to be audited by CertiK. Its suggested check is to verify whether a project is listed on Skynet, CertiK's own platform. The post names one case, a project called Lymex that had been presented as CertiK-audited. CertiK's words: "Lymex never received our services."
IOSCO's investor alert portal, I-SCAN, carries an entry for "CertiK Audit (imposter)", sourced from New Zealand's Financial Markets Authority and published by the FMA on 2026-05-28, under the category of registered or licensed entity impersonators. The FMA link it points to is the regulator's page on recovery scams. In other words, an audit firm's name can turn up inside a scam. If someone contacts you claiming to be an auditor, the same rule applies: check with the firm through its own website.
03Which version: scope, commit hash, contract address
An audit only covers the code the auditor actually read, and the Scope section is where that's spelled out. Hashlock describes the scope as defining exactly which parts of the project were reviewed, and says a report typically lists the Git commit hash of the audited codebase. ChainSecurity adds the part people skip: the scope lists the files that were in, and says which ones were not. For a non-coder, the exclusions are the part to read closely.
Then look for a version marker. Portals.fi is direct about it: if the scope has neither a commit hash nor a contract address, you can't verify that the deployed code matches what was audited.
That's the whole job of this column. Take the address in the report and compare it, character by character, with the contract you're about to interact with. If they match, the report is about your contract. If they don't, or there's no address at all, it's about some other code.
04Severity: what each level means
Per ChainSecurity, findings are usually sorted into four levels: Critical, High, Medium and Low. Many reports add an Informational or Observation tier for style and best-practice notes, which aren't vulnerabilities.
What each severity level means depends on the firm. Hacken's report pages define them like this:
- Critical: usually straightforward to exploit, and can lead to loss of user funds or manipulation of contract state.
- Medium: in most cases cannot lead to asset loss.
- Low: no significant impact on code execution; does not affect the security score, but can affect the code quality score.
Wording varies between firms, so read the definitions printed in the report you're holding.
Two easy misreads. A long list of informational items isn't a bad sign on its own; Portals.fi's view is that it often just means the review was thorough. And severity can move during back-and-forth. Hashlock notes that teams see the findings and recommended fixes before a report is published; Portals.fi says to watch for severity downgrades after a client rebuttal. If there's a "client response" field, read it.
05Status: fixed, acknowledged, or left alone
ChainSecurity's advice comes in two steps. First, did the team fix the issue or choose not to? Second, if they fixed it, did the auditing team sign off on the fix? A team saying "fixed" with no auditor confirmation is, for my purposes, still open.
Firms don't agree on labels. Portals.fi lists "acknowledged, fixed, disputed, accepted risk, etc." Using Hashlock's definitions for the common ones:
- Resolved: the vulnerability has been fully fixed.
- Acknowledged: the team recognises the issue but has chosen not to address it at the time of reporting.
- Unresolved: neither fixed nor formally acknowledged by the project.
The Hacken report in section 06 uses a different word, Unfixed, which simply means not fixed.
Acknowledged sounds reassuring. It means the issue is still there.
At the heavy end, Portals.fi's take is that a live critical that wasn't fixed before deployment is "essentially disqualifying." That's one blog's judgement, not an industry rule. I use it the same way, though: if I see that, I stop reading.
06One public report, column by column: 10/10, nothing fixed
The example is a public report on Hacken's site titled "[SCA] Gate.io | ERC20 | Mar2022", dated 3 March 2022, with the final report logged in its changelog as 04/03/2022. It covers an ERC20 token contract. I picked it only because all four columns are easy to find; it isn't a verdict on that contract, that client or any token. For transparency: Gate.io is also the exchange behind the referral links in some of this site's tutorials; here its report is only a reading sample.
| Column | What the report says | How to read it |
|---|---|---|
| Who | Hacken; report page on the hacken.io domain | Findable on the auditor's own site — passes |
| Scope | Assets in Scope: Deployed contract; Whitepaper: Not provided | The deployed contract was reviewed; no whitepaper was supplied |
| Severity | 2 findings in total: 1 Low, 1 Observation; 0 Critical, 0 High, 0 Medium | Nothing in the levels that touch funds |
| Status | The Low and the Observation are both marked Unfixed; 0 Resolved | Neither finding was fixed |
The two findings are "Public functions not used internally" (Low, Unfixed) and "Outdated Solidity compiler" (Observation, Unfixed).
Now the biggest number on the page: 10/10 Security Score. The report's own summary says the code contained 0 critical, 0 high, 0 medium and 1 low severity issues, that 0 were addressed and resolved, and that this led to a score of 10 out of 10.
Nothing fixed, full marks. The reason is in the Low definition from section 04: low-severity issues don't affect the security score. By the report's own grading, both open items sit in code-quality territory, not in the levels that touch funds. But the page makes the point neatly: score and fix status are separate columns, and a perfect score doesn't mean everything was fixed. On a different report, the same 10/10 could sit next to something else, and someone reading only the score would never know.
The report also tells users they should acknowledge all the risks summed up in its risks section. In other words, the report itself asks you not to stop at the score; find the risk notes and read them through.
07What an audit can't see, and a three-step check
An audit can't guarantee safety, and the auditors concede this themselves. Hashlock: an audit cannot guarantee complete security, and not every issue may be found. Portals.fi: audits reduce risk but do not eliminate it.
What follows is my own judgement, not something those sources say: a code audit looks at code. Whether a team walks away, how the tokens are split, how many tokens the team quietly holds, promises made off-chain, who sells when tokens unlock — none of that is inside a contract audit. The ways launch participants most often lose money, covered in whether launches really pay, aren't things an audit can block, and opening-day selling is its own topic in who sells at the open.
When a launch is close and time is short, I squeeze the audit check into three steps:
- Find the report on the auditor's own website. If it isn't there, treat the project as unaudited.
- Count Critical and High findings and read their status. Anything unfixed, and you can stop here.
- Match the contract address in the scope against the one you'll interact with. No address, and the report can't vouch for the code on-chain.
Pass all three and you've cleared this one column. Everything that couldn't be checked before still can't be.
Checked against auditors' public pages and published material on 2026-10-13. The reading method in sections 01 and 03–05 comes from public blog posts by ChainSecurity, Hashlock and Portals.fi. Section 02 on fake audits draws on CertiK's blog and an IOSCO I-SCAN alert; we did not go further into the FMA's own page. The score, counts, statuses and definitions in section 06 are what Hacken's public report page showed that day; if the page changes, the auditor's page is authoritative. This site does not audit code, has not reviewed any project's code, and makes no safety call on any project, token or platform. We recommend nothing. Bear in mind that every one of these sources sells audits or related products — they describe how to read a report, they are not neutral referees.
The reading order (summary first, four severity levels, scope and exclusions, auditor sign-off on fixes, no promise of bug-free code) follows ChainSecurity, "How To Read Smart Contract Audit Reports" (2023-04-03). The section 06 example is Hacken's audit page "[SCA] Gate.io | ERC20 | Mar2022". False audit claims and the Skynet check come from CertiK's post on misuse of its brand and fake audits (2024-01-17). Scope, commit hashes and status definitions were also checked against Hashlock's blog post "How to Read a Smart Contract Audit Report" (2026-02-20); version markers, severity downgrades and status labels against a Portals.fi blog post (2026-04-18); and the impostor entry against IOSCO I-SCAN alert no. 52300. All links are information pages with no referral codes. Verified 2026-10-13.