SoftwareTestPilot
Security TestingPublished: 13 min read

Best API Security Testing Tools: 42Crunch, Akamai, Salt

Compare 42Crunch, Akamai API Security and Salt Security by testing stage, mapped to the OWASP API Top 10, with a worked BOLA check QA engineers can run.

SoftwareTestPilot
QA Editorial Team
Share:XLinkedInWhatsApp
Best API Security Testing Tools: 42Crunch, Akamai, Salt: Security Testing article cover, SoftwareTestPilot.com
Best API Security Testing Tools: 42Crunch, Akamai, Salt: Security Testing article cover, SoftwareTestPilot.com

Which API security testing tool should you use?

There is no single best API security testing tool, because the leading products test different stages of an API's life. Choose 42Crunch if your team writes OpenAPI definitions and wants to catch security problems in the contract and then test that the running API respects it. Choose Akamai API Security if you need to find every API in your traffic and code, then run automated attack tests and protect APIs in production. Choose Salt Security if your biggest problem is unknown APIs, inconsistent standards across teams, and runtime attacks that look like normal requests.

For QA engineers, the practical answer is usually a pair: one tool that tests APIs before release, plus your own focused tests for authorization rules that only your team understands. A free scanner such as OWASP ZAP is a sensible place to learn before a company buys a commercial platform.

API security testing means sending requests to an API, including deliberately wrong or hostile ones, to check that it rejects what it should, protects data that belongs to other users, and does not leak more than the caller needs. It is different from functional API testing, which checks that correct requests return correct results.

How we compared these tools

We did not run paid trials of 42Crunch, Akamai or Salt Security for this article. The comparison is based on each vendor's public documentation and product pages, linked next to each claim, plus our own small worked example that we ran locally. Feature lists change often, so confirm anything important with the vendor before you buy.

We judged each tool on five questions that matter to a QA team:

  1. When does it test? At design time (the API definition), before release (a running test environment), or in production (live traffic).
  2. What does it find? Contract mistakes, missing authentication, broken authorization, data exposure, or attacks in progress.
  3. Does it fit a pipeline? Can it run in CI/CD and fail a build with clear evidence?
  4. Does it need traffic or a spec? Some tools need an OpenAPI file; others learn from real traffic or cloud configuration.
  5. Is it safe to run? Active tests can change or delete data, so where they are allowed to run matters.

We used the OWASP API Security Top 10 (2023) as the reference list of risks. Its first entry, Broken Object Level Authorization (often called BOLA), is the one QA teams most often miss, so our worked example focuses on it.

API security testing tools at a glance

ACCELQ is listed first as SoftwareTestPilot's standing partner placement; it is a functional API automation tool rather than a dedicated security scanner, and is included because security checks usually sit alongside functional API suites. The order does not represent a measured ranking.

ToolMain stageWhat it focuses onNeedsBest fit
ACCELQBefore releaseCodeless functional API, web and mobile automation where you can add negative and role-based checksTest environmentTeams that want security-minded checks inside their regular API regression
42CrunchDesign time and before releaseStatic audit of OpenAPI definitions, then dynamic scans of the live API against that contractOpenAPI (or GraphQL) definitionSpec-first teams that want security in the developer workflow
Akamai API SecurityCode to runtimeAPI discovery, posture, automated attack-style testing, runtime detectionTraffic, code or specsLarger organisations, especially those already on Akamai
Salt SecurityInventory and runtimeDiscovery of shadow and zombie APIs, posture governance policies, behaviour-based attack detectionCloud connectors and trafficSecurity teams governing many APIs across many teams
OWASP ZAPBefore releaseFree, open-source web and API scanning, including importing API definitionsTest environmentLearning, small teams and budget-limited projects

Read the table as a map of stages, not a leaderboard. A spec-audit tool and a runtime-protection platform answer different questions, and many organisations use both.

42Crunch: security checks that start with the API contract

42Crunch is built around the API definition. Its support documentation explains the difference between its two main checks: Security Audit performs static analysis of the API contract file without calling the API, while Conformance Scan calls a real endpoint to find requests that are outside the contract but still get handled instead of rejected, such as undocumented paths, unexpected HTTP methods, or payloads that break the documented formats.

What it does well

  • Finds problems early. An audit can flag a missing security scheme or an unbounded string field while the API is still a design document.
  • Tests the contract against reality. According to the API Scan documentation, the newer Scan v2 engine supports conformance scans for OpenAPI and GraphQL, plus lightweight drift scans on deployed APIs to check they keep working the expected way.
  • Grows with your tests. The Scan v2 engine adds scan scenarios, unhappy path tests and custom tests.

Limitations to know

  • Its value depends on a reasonably accurate OpenAPI definition. Teams without specs will spend time writing them first.
  • 42Crunch warns that scans generate real traffic and can affect data. Its terms say invasive scans must run only on APIs you own, and only against non-production systems and data; only the non-invasive drift scan is meant for production.
  • A contract check cannot know your business rules. It will not know that a support agent may view an order but must not refund it.

Choose it when your team designs APIs with OpenAPI, wants developers to fix issues before code review, and needs a repeatable scan in the pipeline.

Akamai API Security: discovery, active testing and runtime protection

Akamai combined its own API product with Noname Security after it closed the Noname acquisition in June 2024, creating a unified product called Akamai API Security. Older roundups that list "Noname Security" separately are describing what is now part of Akamai.

What it does well

  • Broad discovery. The product page describes continuous discovery across traffic, code, specs and connected infrastructure, including shadow, zombie and AI-linked APIs. Akamai's API discovery reference documents how discovered APIs appear in traffic.
  • Automated attack-style testing. The Active Testing brief describes automated testing that simulates real attack paths to find issues such as authorization gaps, broken object access and business logic flaws, run on demand, on a schedule, or in CI/CD.
  • Evidence for developers. Akamai says findings include the affected endpoint, the test that triggered the issue and context to reproduce it, which is what a QA engineer needs to file a useful defect.

Limitations to know

  • It is an enterprise platform. Setup involves security and platform teams, not just QA.
  • Discovery from traffic only sees APIs that receive traffic; documented thresholds apply to what counts as a discovered API.
  • As with any automated attack testing, confirm which environments are approved before running it.

Choose it when you have many APIs, need one view from code to production, and want automated testing plus runtime protection from the same vendor.

Salt Security: knowing which APIs exist and spotting abuse

Salt Security approaches the problem from inventory and behaviour. Its API discovery page focuses on finding internal, external and third-party APIs, including undocumented shadow APIs and deprecated zombie APIs that still answer requests.

What it does well

  • Inventory without traffic. Salt Connect uses read-only connectors to AWS, Azure, GCP and GitHub to build an inventory from configuration, so APIs that rarely receive traffic can still be found.
  • Posture rules. Its posture management offering provides pre-built and custom policies, so a security team can check that every API meets the same standards, such as requiring authentication.
  • Behaviour-based detection. Salt Protect builds baselines per API, user and session to detect abuse such as BOLA and scraping that uses valid-looking requests.

Limitations to know

  • Its strengths are governance and runtime. QA teams looking for a pre-release test runner should check how its testing features fit their pipeline before assuming they replace a scanner.
  • Runtime detection finds attacks after release; it complements, not replaces, tests that stop bugs from shipping.

Choose it when nobody can answer "how many APIs do we have and who owns them?", or when you need to spot misuse of APIs already in production.

Which OWASP API risks each type of tool can catch

This decision table is our own summary of how the tool types relate to common risks. Treat it as a planning aid, not a vendor guarantee.

OWASP API risk (2023)Spec audit (e.g. 42Crunch Audit)Active/dynamic testingRuntime detectionYour own QA tests
API1 Broken Object Level AuthorizationLimitedPartly, with two test usersYes, after releaseStrong: you know who owns what
API2 Broken AuthenticationFlags missing security schemesYesYesYes
API3 Broken Object Property Level AuthorizationFlags loose schemasYes (extra fields, mass assignment)PartlyYes
API4 Unrestricted Resource ConsumptionFlags missing limitsYes, carefullyYesRate-limit checks
API5 Broken Function Level AuthorizationLimitedPartlyPartlyStrong: role matrix tests
API9 Improper Inventory ManagementNoNoDiscovery toolsNo

The pattern is clear: authorization bugs depend on business rules, so automated tools need help from tests written by people who know those rules. That is where QA engineers add the most value.

Worked example: a BOLA check a QA engineer can write

This is an illustrative example using a fake orders API written in plain Python, so it runs without any server or account. Asha owns order 1001. Ravi is a different customer. The rule: Ravi must not be able to read Asha's order. The API should answer 404 (not 403) so it does not reveal that the order exists.

# Illustrative BOLA (API1:2023) check against a fake orders API.
ORDERS = {"1001": {"owner": "asha", "total": 1299},
          "1002": {"owner": "ravi", "total": 499}}
TOKENS = {"tok-asha": "asha", "tok-ravi": "ravi"}

def get_order(order_id, token, check_owner):
    user = TOKENS.get(token)
    if user is None:
        return 401, None
    order = ORDERS.get(order_id)
    if order is None:
        return 404, None
    if check_owner and order["owner"] != user:
        return 404, None   # hide that the order exists
    return 200, order

def bola_cases():
    # (description, order_id, token, expected status)
    return [("owner reads own order", "1001", "tok-asha", 200),
            ("other user reads order", "1001", "tok-ravi", 404),
            ("no token", "1001", "", 401)]

for build, check in (("buggy build", False), ("fixed build", True)):
    failures = 0
    for desc, oid, tok, want in bola_cases():
        got, _ = get_order(oid, tok, check)
        ok = got == want
        failures += not ok
        print(f"{build:12} {desc:24} expected {want} got {got} {'PASS' if ok else 'FAIL'}")
    print(f"{build}: {'BLOCK RELEASE' if failures else 'OK'} ({failures} failing)\n")

We ran this script with Python 3 and it printed:

buggy build  owner reads own order    expected 200 got 200 PASS
buggy build  other user reads order   expected 404 got 200 FAIL
buggy build  no token                 expected 401 got 401 PASS
buggy build: BLOCK RELEASE (1 failing)

fixed build  owner reads own order    expected 200 got 200 PASS
fixed build  other user reads order   expected 404 got 404 PASS
fixed build  no token                 expected 401 got 401 PASS
fixed build: OK (0 failing)

Why this works

  • It uses two real users. Most BOLA bugs are invisible with a single test account, because the owner is always allowed.
  • It checks the exact status code, not just "not 200", so a fix that returns 500 does not quietly pass.
  • It runs the same cases against both builds, which makes the regression obvious to developers.

Adapting it to a real API

  1. Create two test users in a non-production environment and save their tokens as pipeline secrets, never in the code.
  2. Replace get_order with an HTTP call, for example using the requests library, to GET /orders/{id}.
  3. List every endpoint that takes an ID in the path or body, and add an "other user" case for each.
  4. Fail the build when any case fails, and attach the request and response to the report.

You can practise these patterns safely on our free API Playground, which gives you a sandbox API to send requests to without touching real systems. For a fuller list of access-control cases, use our RBAC security testing checklist.

Where API security testing fits in your pipeline

A simple, realistic layout for a team starting out looks like this:

  1. On every pull request: lint and audit the OpenAPI definition, and run fast authorization tests like the example above.
  2. On every merge to the test environment: run a dynamic scan (a conformance scan, ZAP, or an active testing product) against the deployed API with test data.
  3. Before a major release: review new endpoints against the OWASP API Top 10 and consider a manual penetration test for high-risk features such as payments.
  4. In production: rely on non-invasive checks, discovery and runtime monitoring, never on destructive scans.

If your organisation already runs code and dependency scanning, our guide to security testing platforms for DevOps covers how SAST, SCA and DAST tools fit alongside API-specific testing.

Common mistakes when adopting API security testing tools

  • Testing with one user. Authorization bugs need at least two users and, ideally, every role.
  • Running invasive scans in production. Fuzzing POST and DELETE operations can create or destroy real records. Keep them in test environments.
  • Trusting an outdated spec. If the OpenAPI file is wrong, a contract-based scan tests the wrong thing. Treat spec drift as a defect.
  • Ignoring undocumented endpoints. Old versions such as /v1/ often stay reachable after /v2/ ships. Ask for an inventory before trusting scan coverage.
  • Drowning in findings. Start with high-severity authentication and authorization results, fix them, then widen the rule set.
  • Assuming a tool replaces thinking. No scanner knows that a trial user must not export reports. Write those checks yourself.

Skills QA engineers need for API security testing

You do not need to become a penetration tester to contribute. The most useful skills are understanding HTTP methods and status codes, reading an OpenAPI definition, handling tokens (including JWTs), designing negative tests, and writing a small amount of code in Python, Java or TypeScript to automate checks.

If you are new to APIs, start with our explanation of the types of API testing, then read the security testing guide for QA engineers. To prepare for interviews where security questions come up, review our API testing interview questions.

Frequently asked questions

Is OWASP ZAP enough for API security testing?

ZAP is a capable free scanner and a good way to learn. It does not know your business rules, so you still need your own authorization tests, and larger organisations may need discovery and runtime features that commercial platforms add.

What is the difference between API security testing and API penetration testing?

Security testing is the broad, ongoing practice, often automated in pipelines. Penetration testing is usually a time-boxed exercise where a specialist tries to break the system manually, often before a major release or for compliance.

Can a QA engineer do API security testing without a security background?

Yes. Start with authentication, authorization and input validation tests, which build on normal API testing skills. Work with your security team before running any active scanning tool.

Do these tools work with GraphQL?

Support varies. 42Crunch documents conformance scanning for GraphQL APIs. Check each vendor's current documentation for the API styles you use.

Your next step

Pick one endpoint in your current project that takes an ID, create a second test user, and write the "other user" check from the worked example. That single test often finds more real risk than a first scan. Then trial one tool from the stage that matches your biggest gap: contract quality, pre-release attacks, or unknown APIs.

Practise safely on the API Playground, and share what your team uses or which bug a scan caught in the QA Community.

References

  1. 1
  2. 2
    42Crunch Audit vs Conformance Scan— support.42crunch.com
  3. 3
    42Crunch API Scan types— docs.42crunch.com
  4. 4
    42Crunch API Scan— docs.42crunch.com
  5. 5
    Akamai API Security— akamai.com
  6. 6
    Akamai Active Testing— akamai.com
  7. 7
  8. 8
    Salt API discovery— salt.security
  9. 9
    Salt Connect— salt.security
  10. 10
    Salt Protect— salt.security
  11. 11
    OWASP ZAP— zaproxy.org