CAPIJ — Certified API Junior (2025 Edition)

In today’s hyperconnected world, software applications rarely operate alone. They depend on Application Programming Interfaces (APIs) to exchange data, orchestrate workflows, and deliver seamless user experiences. This chapter explains what APIs are, why they matter, and how the two most common web styles—SOAP and REST—compare.

What is an API?

An API is a contract that defines the rules, protocols, and data formats that allow one software component to interact with another. Web APIs typically communicate over HTTP, enabling mobile apps, web services, and integrations to request data or trigger actions across distributed systems.

Why are APIs important?

APIs power modular architectures, accelerate development by reusing services, and enable third-party integrations. They also expand the attack surface if they are not secured properly, which is why this certification couples functionality with security throughout the syllabus.

SOAP vs. REST

SOAP is a strict protocol that uses XML envelopes and can be stateful, making it popular in enterprise environments. REST is an architectural style that leverages HTTP verbs and is typically stateless, often using JSON for payloads.

SOAP example

<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
  <soap:Body>
    <m:GetStockPrice xmlns:m="http://www.example.org/stock">
      <m:StockName>GOOG</m:StockName>
    </m:GetStockPrice>
  </soap:Body>
</soap:Envelope>

REST example

POST /stocks
{
  "stock": "AAPL",
  "price": "145.00"
}

API authentication & authorization

Learn how APIs validate and authorize callers using methods such as Basic Auth, API keys, Bearer tokens, OAuth 2.0, JSON Web Tokens (JWT), OpenID Connect, and both role-based (RBAC) and attribute-based (ABAC) access controls. We examine rate limiting, token leakage, man-in-the-middle threats, and IDOR risks to show how security decisions influence exposure.

API architectures

Explore monoliths vs. microservices, API gateways, serverless platforms, GraphQL schemas, stateful vs. stateless design, versioning strategies, and the importance of logging, monitoring, and documentation. Each topic highlights how architecture and governance choices affect security posture.

Documentation matters

Strong documentation drives safer integrations. We cover the critical components of good docs, the role of OpenAPI and Swagger, Postman collections, common documentation pitfalls, and how transparency balances with security expectations.

The chapter concludes with next steps that bridge into deeper security testing, ensuring you understand both the power and risk inherent in API-first ecosystems.

Master the tooling landscape used by pentesters, QA teams, and developers to exercise APIs. This chapter focuses on four core toolsets: cURL, Postman, SOAP UI, and Python.

cURL

Discover why cURL is the command-line workhorse for crafting HTTP requests, manipulating headers, handling authentication, and transferring files. You will practise GET and POST requests, custom headers, data formats, redirects, verbose output, cookies, and file operations.

Postman

Use Postman’s graphical interface to organise requests into collections, manage environments, collaborate with teams, automate tests with pre-request scripts and Newman, and simulate APIs with mock servers.

SOAP UI

Build SOAP and REST projects, import WSDLs, create assertions, run data-driven tests, extend functionality with Groovy scripts, and stand up mock services to mirror production behaviour for deeper validation.

Python

Employ Python’s requests library for automation, including authenticated requests, JSON handling, query parameters, exception handling, file transfers, and session management. Learn where scripting fits in automation, integration, data processing, and testing workflows.

Each tool section ends with use cases and guidance on weaving the utilities into CI/CD pipelines, ensuring you can pivot between manual exploration and scripted coverage.

Examine the 2019 OWASP API Security Top 10, understanding how each risk manifests, how to test for it, and how to remediate it. Real-world examples accompany every category.

1. Broken Object Level Authorization: Identify BOLA conditions by enumerating object identifiers and enforcing server-side checks.
2. Broken User Authentication: Evaluate password policies, session management, and MFA expectations.
3. Excessive Data Exposure: Spot over-shared fields in responses and implement output filtering.
4. Lack of Resource & Rate Limiting: Detect DoS or brute-force gaps and configure throttling.
5. Broken Function Level Authorization: Prevent privilege escalation by validating roles and permissions on every endpoint.
6. Mass Assignment: Guard against auto-binding vulnerabilities by whitelisting properties and using DTOs.
7. Security Misconfiguration: Harden platforms by removing defaults, locking down services, and sanitising errors.
8. Injection: Apply parameterisation and sanitisation to block SQL, NoSQL, and command injections.
9. Improper Assets Management: Track and retire deprecated or test endpoints before attackers find them.
10. Insufficient Logging & Monitoring: Instrument APIs so anomalies trigger alerts and evidence is preserved.

Labs pair exploitation exercises with mitigation plans, building the habits required to protect APIs in the wild.

Update your threat models with the 2023 list of OWASP API risks. Learn what changed, how attackers exploit each weakness, and the mitigation controls modern platforms demand.

1. BOLA: Revisit object-level authorization in multi-tenant and service-to-service contexts.
2. Broken Authentication: Reinforce credential hygiene, token lifecycles, and adaptive MFA.
3. Broken Object Property Level Authorization: Prevent property-level tampering and mass assignment.
4. Unrestricted Resource Consumption: Enforce rate limits, payload size checks, and concurrency ceilings.
5. Broken Function Level Authorization: Lock down privileged operations across orchestration layers.
6. Unrestricted Access to Sensitive Business Flows: Protect high-impact endpoints with additional verification.
7. Server-Side Request Forgery: Contain SSRF by validating outbound destinations and segmenting networks.
8. Security Misconfiguration: Automate drift detection and apply least privilege in every environment.
9. Improper Inventory Management: Maintain API inventories so deprecated services do not linger.
10. Unsafe Consumption of APIs: Treat upstream services as untrusted, validating and sanitising responses.

Scenario-driven labs reinforce how to communicate risk to stakeholders while deploying layered defenses.

Pentesting success relies on thorough planning, reporting, and collaboration. This chapter covers the Test Plan, Test Report, and Test Debrief Meeting in depth.

Test Plan

Learn how to define scope, objectives, methodologies, and logistics. We explore NDA handling, documentation intake, and aligning on grey-box strategies using OWASP guidance.

Test Report

Build executive summaries, methodology narratives, detailed findings, and remediation recommendations. Sample structures illustrate how to present evidence for vulnerabilities like SQL injection, XSS, and IDOR.

Test Debrief Meeting

Facilitate debriefs that engage pentesters, developers, security teams, and stakeholders. The agenda emphasizes remediation timelines, lessons learned, and next steps.

Communication artefacts keep teams aligned from kickoff to remediation, ensuring findings turn into lasting fixes.

Understand how API firewalls act as a specialised shield for web services, how to deploy them responsibly, and how ethical bypass testing strengthens defenses.

Essentials

Define API firewalls, their role in filtering malicious traffic, and the threats they address, from injection to broken authentication.

Installation

Compare deployment models (reverse proxy, sidecar/service mesh, inline appliance), configure rules, schema validation, rate limiting, authentication checks, and logging, then verify protections through testing.

Ethical bypass techniques

Review authorised testing tactics—input evasion, HTTP verb tampering, header manipulation, request smuggling—and the mitigations that keep defences resilient.

The chapter closes with continuous improvement strategies so your firewall posture evolves alongside emerging attacks.

Build fluency in HTTP verbs—the foundation of RESTful design. We cover semantics, safety, idempotence, and best practices for methods such as GET, POST, PUT, PATCH, DELETE, HEAD, and OPTIONS.

• GET: Safe and idempotent retrieval of resources.
• POST: Non-idempotent creation or server-side processing.
• PUT: Idempotent replacement or creation of resources.
• PATCH: Partial updates, idempotent when designed carefully.
• DELETE: Idempotent removal of resources.
• HEAD & OPTIONS: Discover resource metadata and communication capabilities.

Additional coverage includes CONNECT, TRACE, WebDAV extensions, and guidance on choosing the right method, managing caching, payload size, and security controls like CSRF protection.

Learn the Common Vulnerability Scoring System (CVSS) v3.1 to communicate risk objectively. We break down Base, Temporal, and Environmental metrics, explain the formulas, and walk through a scoring example.

Understand exploitability metrics (Attack Vector, Attack Complexity, Privileges Required, User Interaction, Scope) and impact metrics (Confidentiality, Integrity, Availability). Then apply Temporal and Environmental adjustments to tailor scores to real-world contexts.

A worked SQL injection example demonstrates calculating Base, Temporal, and Environmental scores, reinforcing best practices like documenting assumptions, recomputing scores as conditions change, and leveraging official calculators.