If you want automated security testing for an API in CI, three names come up first: ZAP, the free and open-source scanner; StackHawk, the commercial developer-focused scanner that grew out of ZAP; and Schemathesis, an open-source tool that generates tests from your API schema.
They overlap less than it seems. This post explains what each one actually tests, what it costs, and which fits which team. All facts are from each project's own docs, repositories and pricing pages as of November 2026, linked inline.
(Disclosure and scope: I build SpecShield, which does **static* API security checks — it reads specs and logs and never sends requests. It isn't a competitor to these three; it does a different job, which I cover briefly at the end. I haven't run StackHawk for this post, so its section is based on its documentation rather than my own tests.)*
The short version
| ZAP | StackHawk | Schemathesis | |
|---|---|---|---|
| What it is | General DAST scanner (web apps + APIs) | Commercial DAST for developers and CI | Property-based API testing from the schema |
| Finds | Injection, misconfiguration, known vulnerability classes | Same classes, plus multi-user authorization testing | Server errors, spec violations, auth bypass, object-level authorization |
| API inputs | OpenAPI, SOAP, GraphQL | OpenAPI, GraphQL, gRPC, JSON-RPC, SOAP | OpenAPI, GraphQL, gRPC |
| Authorization (BOLA) testing | Manual setup | Yes ("Business Logic Testing", 2+ user profiles) | Yes (object_level_authorization, 2+ peers) |
| License / price | Apache-2.0, free | Wingman $10/user/mo (14-day trial); Scale custom | MIT, free |
| Runs as | Docker scripts, desktop app, daemon | CLI in CI | Python CLI, pytest plugin |
ZAP: the free, broad scanner
ZAP is one of the most widely used DAST tools in the world: Apache-2.0, around 16,000 GitHub stars, latest stable release v2.17.0. It started as an OWASP project; since September 2024 it's ZAP by Checkmarx. Its project leads joined Checkmarx, and it continues as a community project under the same license.
For APIs, the relevant piece is the API scan, a script in ZAP's Docker images:
docker run -t zaproxy/zap-stable zap-api-scan.py \ -t https://staging.example.com/openapi.json -f openapi It imports an OpenAPI, SOAP or GraphQL definition and runs an active scan tuned for APIs: it skips checks that don't apply (like XSS) and adds alerts for server errors and for responses with content types unusual for an API.
Strengths: free, mature, huge rule set for classic vulnerability classes (injection, misconfiguration, information leaks), and an active community.
Weaknesses for API teams: it was built as a web-app proxy and scanner, and that shows. Authenticated scanning requires a context file with users defined in it, and testing whether user A can read user B's objects needs manual setup rather than a built-in check. Results are alerts by vulnerability class, not by API operation.
StackHawk: ZAP's lineage, packaged for CI
StackHawk was originally built on ZAP. In June 2024 it announced its own engine, HSTE, which it describes as an internal fork of ZAP that lets it "rework, remove and replace ZAP's internals." StackHawk also funds ZAP contributions through its ZAP Fund.
What you pay for is mostly the developer workflow around the scanner:
- Configuration in a YAML file in your repo, with a CLI (HawkScan) that runs locally or in CI.
- API inputs including OpenAPI, GraphQL, gRPC, JSON-RPC and SOAP.
- Authenticated scanning: form login, HTTP auth and third-party OAuth.
- Business Logic Testing (launched December 2025): you configure two or more user profiles, and it tests horizontal access (user A reading user B's data — BOLA) and vertical access (a member calling admin functions — BFLA).
- Findings triaged in a dashboard, with fix guidance aimed at developers.
Pricing: Wingman is $10 per user per month with unlimited apps and 50 scans per user per month, and a 14-day trial with no card required. Scale (org-wide, SSO, attack-surface discovery, sensitive-data detection, unlimited scans) is quoted by sales.
Strengths: the CI experience, authorization testing that's configured rather than scripted, and support.
Weaknesses: it's a paid product with a per-user model, and like any DAST it needs a running environment with test users and data. The authorization testing is only as good as the user profiles and data you give it.
Schemathesis: tests generated from your schema
Schemathesis (MIT, ~3,800 stars, v4.33.4 released 12 November 2026) comes from a different tradition. It isn't a vulnerability scanner. It's a property-based testing tool built on Hypothesis: it reads your schema, generates valid, edge-case and invalid inputs, chains operations into stateful workflows, and checks every response.
schemathesis run https://staging.example.com/openapi.json Its built-in checks are on by default. The security-relevant ones:
| Check | What it catches |
|---|---|
ignored_auth | A protected operation accepts requests with missing or invalid credentials |
object_level_authorization | One user can read another user's object (OWASP API1). Needs two or more configured peers |
use_after_free | A deleted resource is still accessible (stateful mode) |
negative_data_rejection | The API accepts input the schema says is invalid |
unsupported_method | An undeclared HTTP method doesn't return 405 |
not_a_server_error | A 5xx — often the first sign of an unhandled injection or parsing bug |
Plus conformance checks: status codes, content types, headers and response bodies must match the schema.
Strengths: it finds the bugs that come from your API's shape — validation bypasses, crashes on edge cases, auth that isn't enforced, broken object-level authorization — and it doubles as contract testing, because every response is checked against the spec.
Weaknesses: it doesn't carry a library of attack payloads for classic vulnerability classes the way ZAP does, and it's only as good as your schema. An endpoint that isn't in the spec never gets tested.
Which finds what
| Problem | ZAP | StackHawk | Schemathesis |
|---|---|---|---|
| SQL / command injection | ✅ attack payloads | ✅ attack payloads | Partial (5xx on generated input) |
| Security headers, misconfiguration | ✅ | ✅ | ❌ |
| Auth not enforced | Partial | ✅ | ✅ ignored_auth |
| BOLA (user A reads user B's data) | Manual | ✅ 2+ profiles | ✅ 2+ peers |
| BFLA (member calls admin function) | Manual | ✅ | ❌ no dedicated check |
| Invalid input accepted | ❌ | ❌ | ✅ |
| Response doesn't match the spec | ❌ | ❌ | ✅ |
| Endpoints missing from the spec | Only if crawled | Only if discovered | ❌ |
How I'd choose
- No budget, want broad vulnerability coverage: ZAP's API scan in CI against staging. Expect to spend time tuning rules and setting up authentication.
- No budget, want API-specific bugs and authorization checks: Schemathesis. Configure two users for the object-level authorization check; that one check is worth the setup.
- Many services and teams, want authorization testing without scripting, budget for tooling: StackHawk. Use the 14-day trial on one service with two real test users before deciding.
- Best free combination: Schemathesis and ZAP. They find mostly different things, and both are free.
The part none of them cover
All three are dynamic: they send requests to a running environment. That leaves two gaps:
- Changes before they deploy. A PR that removes
securityfrom an endpoint or addsclient_secretto a response is visible in the spec diff before anything runs. A DAST only finds it after deployment to staging, and only if the scan covers that endpoint. - Endpoints that aren't in the spec. Every tool above is driven by the spec or by crawling. An old
/v1route still serving traffic, or/actuator/envanswering 200, can sit outside both.
This is the gap SpecShield covers, statically. specshield gate --security blocks the PR that weakens auth. specshield audit --logs compares your access logs with the spec to find undocumented endpoints, old versions still answering, and exposed files like /.env. It sends no requests, so it can't confirm a vulnerability the way a DAST can. It complements these tools; it doesn't replace them.
Running one of these in CI? I'd like to know which findings were real and which were noise — especially for BOLA testing, which is where these tools differ the most.

