
What Is ASVS? OWASP Application Security Verification Standard Explained
ASVS is the OWASP Application Security Verification Standard, an open framework that gives teams a clear, testable list of security requirements for web applications and APIs. Instead of vague advice such as “build secure apps,” ASVS turns security into requirements you can check one by one — and prove, with evidence, that your application meets them.
In this guide, you will learn what ASVS is, what it stands for, how its three levels work, what it covers, how it differs from the OWASP Top 10, and how to use it on a real project without turning it into a paperwork exercise.

What Is ASVS?
ASVS stands for Application Security Verification Standard. It is a flagship project of OWASP, the Open Worldwide Application Security Project, and it provides a basis for testing web application technical security controls. The current stable release is ASVS 5.0.0, published on 30 May 2025, and it is available as a PDF, a Word document and a spreadsheet of requirements, so teams can use it in the format that fits their work.
Think of ASVS as a shared yardstick. Developers use it to know what to build, testers use it to know what to verify, and buyers use it to say, in a contract, exactly what level of application security they expect from a supplier. Because every requirement is written to be verifiable, two different reviewers should reach the same answer about whether an application passes or fails it.
ASVS was first introduced in 2008 and has been revised several times since, with version 3.0 in 2016 and version 4.0.3 before the 5.0.0 release. That long history matters: the standard reflects lessons from real applications and real attacks, not a single vendor’s checklist.
What Does ASVS Stand For?
ASVS stands for Application Security Verification Standard. The three words in the name each carry meaning:
- Application — the scope is the application itself: its code, its configuration, its authentication, its data handling and its interfaces, including APIs.
- Security — the requirements cover protection against the attacks web applications actually face, from injection to broken access control.
- Verification — every requirement is meant to be checked. A claim is not enough; there must be a test, a review or an observation that shows the control works.
In short, ASVS does not tell you to “be secure.” It tells you, requirement by requirement, what secure looks like — and how to prove it.
The Three ASVS Levels
ASVS is organised into three levels. The levels are cumulative: Level 2 includes Level 1, and Level 3 includes Levels 1 and 2. Choosing a level is a risk decision, not a badge to collect.
| Level | Who It Is For | What It Assumes | Typical Use |
|---|---|---|---|
| Level 1 — Opportunistic | Most web applications | An attacker with ordinary tools and public information | A first baseline for any application that handles user accounts or data |
| Level 2 — Standard | Applications handling sensitive data or money | A skilled, motivated attacker who will probe the application in depth | The default target for business and customer-facing systems |
| Level 3 — Advanced | High-value, high-risk systems | A determined attacker with time, resources and advanced techniques | Banking, health, critical infrastructure and similar systems |
Most teams should aim for Level 1 everywhere and Level 2 for anything that stores personal data, takes payments or makes decisions that affect people. Level 3 is for the small number of systems where a breach would be catastrophic. Picking Level 3 for a simple marketing site wastes effort; picking Level 1 for a payment system leaves real risk untested.
What Does ASVS Cover?
ASVS covers the full life of a web application, from how it is built to how it is operated. Its chapters include, among others:
- Encoding and sanitisation — stopping injection, including SQL injection and operating-system command injection.
- Authentication — passwords, multi-factor authentication, credential recovery and protection against brute force.
- Session management — secure session tokens, timeouts and logout.
- Access control — making sure each user can only reach the data and actions they are allowed to use.
- Cryptography — using proven algorithms, protecting keys and encrypting sensitive data.
- Input validation and output encoding — treating every input as untrusted until it is checked.
- Error handling and logging — failing safely, logging security events and protecting log data.
- Data protection and privacy — handling personal data carefully and limiting what is collected and kept.
- APIs and web services — securing the interfaces that mobile apps and partners call.
- Configuration and deployment — secure defaults, patched components and safe cloud settings.
That breadth is the point. A strong password policy does not help if an API lets any authenticated user read another user’s records. ASVS forces teams to look at the whole application, not just the part they already feel good about. If you are starting from scratch, read our guide to what a secure application is and how secure apps are built alongside this standard.
ASVS vs OWASP Top 10: What Is the Difference?
Newcomers often confuse ASVS with the OWASP Top 10. They are related, but they do different jobs.
| Question | OWASP Top 10 | ASVS |
|---|---|---|
| What is it? | A ranked list of the ten most serious web application risks | A detailed standard of verifiable security requirements |
| Best for | Awareness and prioritisation | Design, testing, procurement and audit |
| Level of detail | Ten broad risk categories | Hundreds of specific requirements, grouped by chapter |
| Can you test against it? | Only in general terms | Yes — each requirement is written to be verified |
| Can you put it in a contract? | Not precisely | Yes — “meet ASVS Level 2” is a testable clause |
Use the Top 10 to explain why application security matters and where the biggest risks sit. Use ASVS when you need to decide, in detail, what a team must build and how a tester will check it. The two work best together: the Top 10 sets priorities, and ASVS supplies the requirements that address them.
Worked Example: Reading an ASVS Requirement
Each ASVS requirement has an identifier in the format chapter.section.requirement. For example, 1.2.5 is the fifth requirement in the Injection Prevention section of the Encoding and Sanitization chapter. In version 5.0.0, it says, in substance: verify that the application protects against operating-system command injection and that operating-system calls use safe, parameterised interfaces rather than building shell commands from user input.
To reference a requirement unambiguously, OWASP recommends including the version, for example v5.0.0-1.2.5. That matters because identifiers can change between versions, and a report that only says “1.2.5” may mean different things in different releases.
Here is how a tester would verify that one requirement on a real application:
- Find every place the application runs an operating-system command, a shell call or a system utility.
- Check whether any of those calls include user-supplied data, directly or through a file name, a parameter or a header.
- Try a controlled input that would change the command if it were built by string concatenation — for example, adding a separator character — in a test environment only.
- Confirm the application uses a safe interface, rejects the attempt, and logs the event, rather than executing the extra command.
- Record the evidence: the code location, the test input, the observed result and the version tested.
That pattern — locate, test, observe, record — is how ASVS turns a paragraph of text into a repeatable check. Apply it to every requirement in scope, and the result is an audit trail a second reviewer can follow. When a check fails, the next step is to confirm it is a real vulnerability, fix it, and retest it, rather than arguing about the wording.
How to Use ASVS in 6 Steps
- Pick a level. Use the table above. Level 1 for a low-risk site, Level 2 for most business applications, Level 3 only where the risk justifies it.
- Scope the application. List its pages, APIs, user roles, data types and third-party components. A requirement cannot be tested if the feature it covers is not in scope.
- Build the checklist. Download the ASVS spreadsheet (CSV) for version 5.0.0 and filter it to your level. Add columns for the owner, the evidence and the result.
- Design and build against it. Give developers the requirements before coding starts, not after testing finds the gaps. Many ASVS failures are cheaper to prevent than to fix.
- Verify with evidence. Test each requirement, record what you observed, and mark it pass, fail or not applicable — with a reason for the last two.
- Fix, retest and repeat. Track failures to closure, retest the fix, and repeat the review on a schedule, not only after an incident.
Teams that treat ASVS as a testing checklist only get half its value. Its greatest return comes when developers use it as a design guide, because a requirement caught at design time costs far less than one found in production.
ASVS Checklist for a First Review
If you have never used ASVS before, start with this short checklist. It does not replace the full standard, but it will surface the most common failures quickly.
| Area | Check | Pass Looks Like |
|---|---|---|
| Authentication | Are passwords stored with a strong, modern hash, and is multi-factor authentication offered? | Hashed passwords, no plain-text storage, MFA available |
| Session | Do sessions expire, and does logout actually end the session server-side? | Short idle timeout, logout invalidates the token |
| Access control | Can a user change an ID in a URL and see another user’s data? | Every request checks the user’s permission for that object |
| Injection | Is user input ever concatenated into a query or a shell command? | Parameterised queries and safe interfaces throughout |
| Cryptography | Is sensitive data encrypted in transit and at rest, with keys protected? | TLS everywhere, encrypted storage, managed keys |
| Logging | Are logins, failures and access-control denials logged, without recording passwords? | Security events logged, secrets never logged |
| Dependencies | Are libraries and frameworks patched, and are unused components removed? | Current versions, no known critical flaws, minimal surface |
Work through that table on a staging copy of your application, and you will have a realistic picture of where you stand before you commit to a full Level 2 review.
Common Mistakes When Using ASVS
- Choosing Level 3 for everything. It slows delivery and burns goodwill. Match the level to the risk.
- Marking requirements “not applicable” without a reason. If it does not apply, say why, in one sentence, so a reviewer can agree or challenge it.
- Testing only the happy path. ASVS requirements are mostly about what happens when input is hostile, a session is stolen or a user is curious. Test the abuse cases.
- Accepting a claim without evidence. “We use encryption” is not evidence. Show the configuration, the code or the test result.
- Treating ASVS as a one-off audit. Applications change every week. A standard you checked once, a year ago, describes a different application.
Frequently Asked Questions
What is ASVS in simple terms?
ASVS is a free, open checklist of security requirements for web applications and APIs, published by OWASP. It tells teams exactly what to build and how testers should verify it.
Is ASVS a certification?
No. ASVS does not involve a formal certification, and OWASP does not certify applications. Teams use it as a standard to test against, and they can state that an application was verified to a given ASVS level, with evidence, but that is a claim about the testing, not an OWASP certificate.
Which ASVS version should I use?
Use the latest stable release, ASVS 5.0.0, published on 30 May 2025, unless a contract or a regulator specifies another version. Always record the version you used, because requirement numbers can change between releases.
How long does an ASVS review take?
It depends on the size of the application and the level chosen. A small application at Level 1 can be reviewed in days; a large, complex application at Level 2 or 3 can take weeks, especially if failures need to be fixed and retested.
Does ASVS replace penetration testing?
No. ASVS gives testers a systematic list to work through, and penetration testing adds creative, attacker-style probing on top of it. The two complement each other: ASVS makes sure nothing on the list is missed, and penetration testing finds the problems the list did not anticipate. For a broader view of how attackers think, see what MITRE ATT&CK is.
Conclusion
ASVS turns application security from an opinion into a test. Choose a level that matches your risk, work through the requirements with evidence, fix what fails, and repeat the review as the application changes. Done that way, ASVS is not a compliance burden — it is the clearest way to know, and to show, that a web application is as secure as it claims to be.


