Point-in-Time Penetration Testing
Raxis Strike
A fixed window, full depth, a report you can hand to an auditor.
Best when you have a launch, an audit, or a first test to get right.
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
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"
} Nothing replaces skill. Illustrative exchange. Valid schema, valid token, wrong customer.
JSON and XML endpoints, method enforcement, OAuth and JWT handling, and the gap between the convention and your implementation.
Introspection, query depth and batching, field-level authorization, and alias tricks that walk past rate limits.
Protobuf services, auth interceptors, reflection, and message validation.
Connections that authenticate once and never re-check, message injection, origin validation.
The APIs nobody can reach, until someone does. Trust between services, tested from inside.
Delegated auth, replay, and data exposure on both sides of the integration.
Secrets shipped in the client, pinning bypasses, and what the backend assumes about who is calling. The app itself is its own test.
Callback URLs and cloud functions: SSRF, replay, signature checks, and cold-start authorization.
WSDL exposure, XXE, WS-Security, and the seam where legacy meets modern.
API1:2023
Change one ID, read another customer. Every endpoint that takes an identifier, at every role.
API2:2023
Weak tokens, reset flows, missing brute-force limits, and logins that leak by timing.
API3:2023
Responses with fields you should not see. Requests that set fields you should not touch.
API4:2023
No rate limit, no page cap, no query budget. What your API costs an attacker to abuse.
API5:2023
Admin functions a standard token can call.
API6:2023
Coupon stacking, scalping, fraud at machine speed. Your API used exactly as designed, faster.
API7:2023
Any endpoint that fetches a URL, pointed at your metadata service.
API8:2023
Verbose errors, permissive CORS, debug endpoints left on.
API9:2023
v1 still answering. Staging in production. The endpoints your team forgot.
API10:2023
What you trust from upstream, and what happens when upstream is compromised.
01
Spec, Postman collection, traffic capture, public repos. We test what’s documented, then what isn’t.
02
No token, standard user, admin, and across tenants. Each boundary, each endpoint, by hand.
03
Rate limits, workflow order, business flows. The bugs a scanner cannot reason about.
04
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.
Raxis Strike
A fixed window, full depth, a report you can hand to an auditor.
Best when you have a launch, an audit, or a first test to get right.
Raxis Attack
Unlimited manual testing all year, findings live the moment we confirm them.
Best when you ship every sprint and the surface never sits still.
Every finding with the exact request that triggered it. Paste it and confirm.
What we reached and what it would have meant, with the evidence.
Remediation written for how your API is built, ranked by what to fix first.
We verify the fix and issue a clean report, at no extra cost.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.