Skip to main content
skill CX Codex

api-testing · fugazi — Claude Code skill for API tests

api-testing is a Claude Code skill for standalone tests of REST and GraphQL contracts. It checks schemas, authentication, errors, pagination, and other API behavior without browser-driven flows.

MIT 112 installs ★ 269 updated 2026-10-21

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add fugazi/test-automation-skills-agents --skill api-testing -a claude-code
Open on GitHub

What api-testing does

The skill guides API tests in TypeScript with Playwright’s request fixture or Supertest, and in Java with REST Assured. Its coverage includes request and response schemas, authentication, error statuses, pagination, idempotency, and rate limits. It is for standalone API checks, not browser-based end-to-end journeys.

Included materials are starter tests for Playwright and REST Assured, an API health-check script, and references on schemas and contracts. TypeScript work requires Node.js 18+, @playwright/test or supertest, and zod. The Java stack calls for Java 21+, REST Assured 5.x, AssertJ, Jackson, and json-schema-validator. Tests will need those dependencies in place before the examples can run.

What it helps with

  • validate REST endpoint response schemas
  • test authentication for GraphQL endpoints
  • cover API error responses and status codes
  • check pagination and boundary inputs
  • verify idempotency for PUT and DELETE

Example prompts for the agent

  • Write standalone REST API tests that check response schemas, authentication, and error cases.
  • Add GraphQL API tests for valid and empty inputs.
  • Check that repeated PUT and DELETE requests remain idempotent.

How to install api-testing

1Skills CLI (Vercel)

npx skills add fugazi/test-automation-skills-agents --skill api-testing -a claude-code

2Manually: put the files in place

~/.claude/skills/api-testing/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/api-testing/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about api-testing

How do I install api-testing in Claude Code?

Run npx skills add fugazi/test-automation-skills-agents --skill api-testing -a claude-code. The skill file is at ~/.claude/skills/api-testing/SKILL.md.

What does api-testing do?

It helps create standalone REST and GraphQL API tests for schemas, authentication, errors, pagination, and idempotency. It does not cover browser-driven E2E flows.

Which dependencies do the TypeScript and Java examples need?

For TypeScript, use Node.js 18+, @playwright/test or supertest, and zod. The Java stack requires Java 21+, REST Assured 5.x, AssertJ, Jackson, and json-schema-validator.

Source text

SKILL.md · MIT
---
name: api-testing
description: 'Test REST and GraphQL endpoint contracts using Playwright request fixture (TypeScript) or REST Assured (Java). Use for standalone API tests covering schemas, auth, status/error handling, pagination, idempotency, rate limits, or contract checks; not for browser E2E specs. Keywords: REST, GraphQL, API contract, schema validation, REST Assured.'
license: 'Complete terms in LICENSE.txt'
---

# API Testing (Playwright + REST Assured)

Comprehensive API testing skill covering both Playwright TypeScript (request fixture, Supertest, Zod) and Java (REST Assured, AssertJ, JSON Schema Validator).

## When to Use This Skill

- Create API tests for REST or GraphQL endpoints
- Validate request/response schemas (Zod, JSON Schema)
- Test authentication flows (OAuth2, JWT, API keys, Bearer tokens)
- Verify error handling (400, 401, 403, 404, 409, 422, 500)
- Test pagination, filtering, sorting edge cases
- Validate idempotency for PUT/DELETE operations
- Contract testing between services
- Rate limiting validation

### Do NOT Use For

- Browser-driven UI flows (use `playwright-e2e-testing` for Playwright specs, or `webapp-selenium-testing` for Selenium)
- Live interactive browser sessions or snapshots (use `playwright-cli`)
- Visual/layout regression (out of scope — no DOM)
- End-to-end journeys that must drive a real browser across pages

## Prerequisites

| Stack      | Requirements                                                          |
| ---------- | --------------------------------------------------------------------- |
| TypeScript | Node.js 18+, `@playwright/test` or `supertest`, `zod`                 |
| Java       | Java 21+, REST Assured 5.x, AssertJ, Jackson, `json-schema-validator` |

## Core Principles

1. **Schema validation on every response** — never trust an unvalidated response
2. **Test all HTTP status codes** — happy path AND error states
3. **Auth testing is mandatory** — verify 401/403 for protected endpoints
4. **Data-driven** — test with valid, invalid, boundary, and empty values
5. **Stateless where possible** — each test cleans up or uses unique data

## Quick Reference — Playwright

```typescript
import { test, expect } from "@playwright/test";

test("GET /api/users returns 200 with valid schema", async ({ request }) => {
  const response = await request.get("/api/users");
  expect(response.ok()).toBeTruthy();
  const body = await response.json();
  expect(body).toMatchObject({ data: expect.any(Array) });
});
```

## Quick Reference — REST Assured

```java
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

import java.util.List;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

@Test
@DisplayName("GET /api/users returns 200 with valid schema")
void getUsers() {
    String token = "test-token";

    given()
        .header("Authorization", "Bearer " + token)
    .when()
        .get("/api/users")
    .then()
        .statusCode(200)
        .body("data", is(instanceOf(List.class)))
        .body("data.size()", greaterThan(0));
}
```


---

## Red Flags

Stop and reconsider if you see any of these in generated API tests:

- Assertions only on status code with no body/schema validation — an unvalidated response hides contract drift.
- Hardcoded secrets/tokens committed to the test file — read from env or a secrets manager.
- Tests sharing mutable state with no cleanup — flaky and order-dependent.
- Skipping auth tests (no 401/403 assertions on protected endpoints) — security regression risk.
- No coverage of error states (only happy-path 200s) — error handling is untested.

---

## References

| Document                                                         | Content                                             |
| ---------------------------------------------------------------- | --------------------------------------------------- |
| [REST API Patterns](./references/rest-api-patterns.md)           | CRUD, pagination, filtering, error patterns         |
| [Playwright API Testing](./references/playwright-api-testing.md) | Request fixture, Supertest, TypeScript patterns     |
| [REST Assured Testing](./references/rest-assured-testing.md)     | REST Assured, AssertJ, Java patterns                |
| [Schema Validation](./references/schema-validation.md)           | Zod (TS), JSON Schema (Java), strict vs loose       |
| [Contract Testing](./references/contract-testing.md)             | Request/response contracts, idempotency, versioning |

## Templates

- [Playwright API Spec](./templates/playwright-api-spec.ts) — starter test file for API testing
- [REST Assured Test](./templates/rest-assured-test.java) — starter Java test class

## Scripts

- [API Health Check](./scripts/api-health-check.sh) — validate API endpoints respond correctly

## Troubleshooting

| Issue                          | Solution                                                                       |
| ------------------------------ | ------------------------------------------------------------------------------ |
| 401 on authenticated endpoints | Verify token is fresh; check expiry; re-authenticate                           |
| Flaky API tests                | Add retry logic; check for rate limiting; use unique test data                 |
| Schema validation too strict   | Use `.passthrough()` (Zod) or `additionalProperties: true` for flexible fields |
| Timeout on slow endpoints      | Increase `timeout` in request options; check for server load                   |

---

## Verification

- [ ] **Schema validation in place** — Every response validated against a schema (Zod or JSON Schema)
- [ ] **Authentication tested** — 401 returned for protected endpoints without valid credentials
- [ ] **Idempotency verified** — PUT/DELETE produce same result when called multiple times
- [ ] **Edge cases covered** — Empty payloads, invalid types, boundary values, SQL injection attempts

© fugazi · MIT · fugazi/test-automation-skills-agents

Similar skills

All skills for Testing and QA →

api-testing by other authors comes first.

api-testing kindlmann The api-testing Claude Code skill helps write REST and GraphQL API tests. It comes into play for schema, auth, error, and pagination checks. CX Codex +1 1,800installs api-testing secondsky api-testing — a skill that gets your agent writing HTTP API tests: Supertest for TypeScript, httpx and pytest for Python. Covers REST, GraphQL and error handling. CX Codex +1 921installs api-testing laurigates api-testing — a skill for writing REST and GraphQL API tests with Supertest (TypeScript) and httpx/pytest (Python). Validates status codes, response schemas, auth flows, and error handling. CX Codex +1 106installs api-testing oakoss api-testing is a Claude Code skill for writing REST API integration tests and checking endpoint responses. It activates for HTTP mocking, response validation, and API error tests. CX Codex +1 149installs playwright-api-testing-cursorrules-prompt-file PatrickJS playwright-api-testing-cursorrules-prompt-file configures Cursor to generate Playwright API tests using pw-api-plugin. It helps test status codes and validate response schemas with Zod. CX Codex +1 ★ 41,178repo stars playwright-testing laurigates The playwright-testing skill guides Playwright E2E work for web apps, including browser coverage, mobile viewports, API checks, and visual snapshots. CX Codex +1 106installs api-security-testing usestrix The api-security-testing skill guides Strix through REST, GraphQL, or gRPC API security tests, then provides a request to reproduce each finding. CX Codex +1 17,500installs testing-api-security-with-owasp-top-10 mahipal testing-api-security-with-owasp-top-10 walks an agent through OWASP API Security Top 10 (2023) checks on REST, GraphQL and gRPC endpoints. Useful for authorized pentests and pre-release endpoint reviews. CX Codex +1 931installs conducting-api-security-testing mahipal The conducting-api-security-testing skill tests REST, GraphQL, and gRPC APIs for access-control, authentication, validation, and business-logic flaws. Use it for authorized API assessments. CX Codex +1 715installs api-testing-patterns proffesor-for-testing api-testing-patterns — a skill with ready-made patterns for testing REST and GraphQL APIs: contracts, auth, idempotency, race conditions. Useful when writing tests or picking a strategy. CX Codex +1 618installs

From the same set4

Project sponsors

Companies that keep this analytics open