API Penetration Testing Services

200 OK. Someone else’s data.

Your API answered exactly as designed. A senior U.S. engineer reads the request, changes one field, and reads the reply as your customer’s data. When we reach what matters, we leave a card.

Request

GET /api/v1/invoices/1048210483
Host: api.example.com
Authorization: Bearer eyJhbGci.9f3a…  tenant A, standard user
Accept: application/json

One field changed.

A scanner grades it

  • Schema valid
  • Auth valid
  • 200 OK

An engineer reads it

BOLA. Critical.

Response

HTTP/1.1 200 OK
Content-Type: application/json

{
  "invoice_id": 10483,
  "customer": "Northwind Holdings",
  "tenant": "B",
  "amount": 48210.00,
  "card_last4": "4417"
}
  • Pass What a scanner grades
  • The one field an engineer changed
  • Another customer's data

Nothing replaces skill. Illustrative exchange. Valid schema, valid token, wrong customer.

What We Test

Bring the spec or don’t. We map what’s documented, then find what isn’t: old versions still answering, endpoints only the mobile app knows about, keys in a public repo. Every protocol, every auth scheme, by hand.

REST

JSON and XML endpoints, method enforcement, OAuth and JWT handling, and the gap between the convention and your implementation.

GraphQL

Introspection, query depth and batching, field-level authorization, and alias tricks that walk past rate limits.

gRPC

Protobuf services, auth interceptors, reflection, and message validation.

WebSocket

Connections that authenticate once and never re-check, message injection, origin validation.

Internal & Microservice

The APIs nobody can reach, until someone does. Trust between services, tested from inside.

Partner & Third-Party

Delegated auth, replay, and data exposure on both sides of the integration.

Mobile Backend

Secrets shipped in the client, pinning bypasses, and what the backend assumes about who is calling. The app itself is its own test.

Webhooks & Serverless

Callback URLs and cloud functions: SSRF, replay, signature checks, and cold-start authorization.

SOAP

WSDL exposure, XXE, WS-Security, and the seam where legacy meets modern.

OWASP API Security Top 10, All of It

Every engagement covers the full OWASP API Security Top 10:2023. Coverage is the floor. The findings that matter are the ones a checklist cannot phrase.

Broken Object Level Authorization

API1:2023

Change one ID, read another customer. Every endpoint that takes an identifier, at every role.

Broken Authentication

API2:2023

Weak tokens, reset flows, missing brute-force limits, and logins that leak by timing.

Broken Object Property Level Authorization

API3:2023

Responses with fields you should not see. Requests that set fields you should not touch.

Unrestricted Resource Consumption

API4:2023

No rate limit, no page cap, no query budget. What your API costs an attacker to abuse.

Broken Function Level Authorization

API5:2023

Admin functions a standard token can call.

Unrestricted Access to Sensitive Business Flows

API6:2023

Coupon stacking, scalping, fraud at machine speed. Your API used exactly as designed, faster.

Server Side Request Forgery

API7:2023

Any endpoint that fetches a URL, pointed at your metadata service.

Security Misconfiguration

API8:2023

Verbose errors, permissive CORS, debug endpoints left on.

Improper Inventory Management

API9:2023

v1 still answering. Staging in production. The endpoints your team forgot.

Unsafe Consumption of APIs

API10:2023

What you trust from upstream, and what happens when upstream is compromised.

How We Test

The pentester on your scope call is the one sending the requests, and the one retesting your fix. Authorization is the whole game, so most of the work is testing it at every boundary your API has.

01

Map the Surface

Spec, Postman collection, traffic capture, public repos. We test what’s documented, then what isn’t.

02

Every Role, Every Endpoint

No token, standard user, admin, and across tenants. Each boundary, each endpoint, by hand.

03

Logic and Abuse

Rate limits, workflow order, business flows. The bugs a scanner cannot reason about.

04

Findings As We Go

Criticals and highs land in Raxis One with the request that reproduces them, and in Jira or GitHub if you connect them. Fix while we keep testing.

Two Ways to Test Your API

Same senior engineers, same manual tradecraft, same live findings. The difference is when you want us on it: once, before a launch or an audit, or every sprint.

What You Get

Written by the engineer who did the work, for the engineer who has to fix it.

The Request That Did It

Every finding with the exact request that triggered it. Paste it and confirm.

Proof of Impact

What we reached and what it would have meant, with the evidence.

Fixes for Your Stack

Remediation written for how your API is built, ranked by what to fix first.

Included Retest

We verify the fix and issue a clean report, at no extra cost.

The Chat Endpoint

Our stories are based on real events encountered by Raxis engineers. Some details have been altered or omitted to protect customer identities.

APIs are meant to take requests from many directions, which is what makes them hard to secure. An API penetration test looks for the opening nobody intended.

Mapping a SaaS product’s API, our pentester found a chat feature that let entitled users query an AI endpoint. Limited roles were only supposed to ask about public information. He replayed the request in Burp Repeater, changed the transaction type, and the endpoint answered with internal data, still authenticated as a limited user.

The proof of concept went into the report. The customer closed the bypass and protected the data.

FAQ: API Penetration Testing

What’s the difference between API testing and web application testing?

API penetration testing focuses on the backend services, authentication, authorization, and business logic of your APIs, testing how they handle requests, process data, and enforce permissions. Web application testing covers the user interface, client-side code, and how users interact with your application through a browser. APIs often handle sensitive data and business-critical functions without the visibility of a UI, which makes them attractive targets. Most modern applications need both.

Can you test APIs that aren’t publicly documented?

Yes. Undocumented APIs are often the most vulnerable because they receive less security scrutiny. We use traffic analysis, reverse engineering, and dynamic testing to discover and map undocumented endpoints, parameters, and functionality. We test REST, GraphQL, SOAP, gRPC, and custom protocols whether documentation exists or not.

Will API testing disrupt our production environment?

Not when done properly. We craft requests to avoid tripping rate limits, exhausting resources, or corrupting data, and we agree testing windows, request rates, and test accounts with your team. We can test against staging, but we recommend at least some production testing, because staging usually differs from production in ways that hide real vulnerabilities.

How do you test authentication and authorization in APIs?

For authentication, we evaluate token generation, session management, password policies, MFA implementation, and credential transmission. For authorization, we test role-based access controls, privilege escalation paths, broken object-level authorization (BOLA, the #1 OWASP API risk), and broken function-level authorization. We create multiple test accounts at different privilege levels and systematically attempt to bypass authorization checks, access other users' data, and perform unauthorized operations.

Can you test APIs that require specific authentication tokens or API keys?

Yes. We test APIs using your existing authentication mechanisms, including OAuth tokens, JWT, API keys, SAML assertions, and custom schemes. You can provide test credentials, or we can work with your team to generate them. We also test the security of the authentication mechanism itself, including weak token generation, insufficient validation, token leakage, and session management flaws.

What types of API vulnerabilities do you typically find?

Broken object-level authorization (BOLA), excessive data exposure, missing rate limits, injection flaws (SQL, NoSQL, command injection through API parameters), business logic abuse, mass assignment, security misconfigurations, and improper inventory management (old API versions still routing traffic alongside newer ones). These map directly to the OWASP API Security Top 10:2023.

Do you test GraphQL APIs differently than REST APIs?

Yes. GraphQL has unique security considerations, including introspection exposure that reveals your entire schema, query depth and complexity attacks that exhaust resources, batch query abuse, field-level authorization gaps, alias-based rate limit bypasses, and information leakage through field suggestions. Our team has extensive experience with GraphQL security and tests it as a distinct attack surface, not as a variation of REST.

How long does API penetration testing take?

A focused API with 10 to 20 endpoints typically takes one to two weeks. Fifty or more endpoints with multiple auth methods and real business logic runs two to three weeks. Enterprise API estates with hundreds of endpoints and many services can take three to six weeks or more. We give you a firm timeline at scoping, and teams that ship continuously can move the same scope into Raxis Attack for ongoing testing.

What documentation or access do you need to test our APIs?

Endpoint URLs, test credentials, and ideally your OpenAPI or Swagger spec or a Postman collection. Role definitions, expected request and response formats, and anything you want us to avoid all help. We can also start with nothing and approach your API the way an attacker would, which is more realistic and takes a little longer.

How do we scope an API penetration test?

Scoping starts with a 30-minute conversation. We need a rough sense of API count, endpoint count per API, authentication mechanisms, role complexity, and the business logic at stake. We can scope from documentation, from a brief technical walkthrough, or both. Most engagements move from scoping conversation to formal proposal within a few days. API testing can also be bundled with our broader penetration testing services.

Who performs the testing?

Senior US-based Raxis engineers holding certifications such as OSCP and OSWE. The engineer on your scope call is the one sending the requests, and the one retesting your fix. No outsourcing, and no junior testers learning on your API.

How much does API penetration testing cost?

Most API penetration tests range from around $5,000 for a focused, single-API assessment to $50,000 or more for enterprise API ecosystems with hundreds of endpoints, multiple authentication schemes, and complex business logic. Endpoint count, the number of user roles to test, and the depth of business logic are what drive scope. We provide a fixed quote after a short scoping conversation, and retesting after remediation is included, not billed separately.

Request a quote

Tell Us What You Need Tested

We usually respond in one business day.

Please let us know what's on your mind. Include any details about your target environment, timeline, or compliance drivers.