Лучшие инструменты для тестирования API в 2026 году

Самый популярный API-клиент в мире. Полная экосистема: коллекции, переменные, тесты, мок-серверы, мониторинг, командная работа.

// Postman Test Script — автотест в коллекции
pm.test("Status 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response has user data", function () {
    const json = pm.response.json();
    pm.expect(json).to.have.property('id');
    pm.expect(json).to.have.property('email');
    pm.expect(json.email).to.include('@');
});

pm.test("Response time < 500ms", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

# Newman — запуск коллекции в CI/CD
npm install -g newman
newman run my-collection.json \
  --environment staging.json \
  --reporters cli,junit \
  --reporter-junit-export results.xml

Open-source альтернатива Postman. Ключевое отличие: коллекции хранятся как файлы в Git, а не в облаке. Никакой регистрации, никакого облака.

# Формат .bru — plain text, git-friendly
meta {
  name: Get User
  type: http
  seq: 1
}

get {
  url: {baseUrl}/api/users/42
  body: none
  auth: bearer
}

auth:bearer {
  token: {authToken}
}

assert {
  res.status: eq 200
  res.body.id: eq 42
  res.body.email: contains @
}

Элегантный API-клиент от Kong. Минималистичный интерфейс, поддержка REST, GraphQL, gRPC и WebSocket. Локальное хранение по умолчанию.

Полностью браузерный API-клиент. Открыл hoppscotch.io — и работаешь. Никакой установки. REST, GraphQL, WebSocket, SSE, MQTT.

Установлен на каждой Unix-системе. Универсальный инструмент для HTTP-запросов. Подробнее — в нашей статье про отладку API.

# GET-запрос с заголовками
curl -s https://api.example.com/users | jq .

# POST с JSON
curl -X POST https://api.example.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer TOKEN" \
  -d '{"name": "Иван", "email": "ivan@test.ru"}'

# Замер времени ответа
curl -o /dev/null -s -w "Total: %{time_total}s\nHTTP: %{http_code}\n" \
  https://api.example.com/health

# Smoke-тест в CI/CD
#!/bin/bash
STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://api.example.com/health)
if [ "$STATUS" -ne 200 ]; then
  echo "Health check failed: $STATUS"
  exit 1
fi

«curl для людей». Интуитивный синтаксис, цветной вывод, автоматическая детекция JSON.

# Установка
pip install httpie
# или: brew install httpie

# GET — не нужен флаг -X
http GET https://api.example.com/users

# POST — JSON по умолчанию (не нужен Content-Type)
http POST https://api.example.com/users \
  name="Иван" \
  email="ivan@test.ru" \
  Authorization:"Bearer TOKEN"

# Скачать файл
http --download https://api.example.com/report.pdf

# Сессии — сохраняют cookies и заголовки
http --session=myapi POST https://api.example.com/login \
  email="admin@test.ru" password="secret"
http --session=myapi GET https://api.example.com/me

Современный инструмент нагрузочного тестирования от Grafana Labs. Сценарии пишутся на JavaScript. Высокая производительность (Go runtime).

// k6-script.js
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '30s', target: 50 },   // разогрев до 50 VU
    { duration: '1m', target: 100 },    // нагрузка 100 VU
    { duration: '30s', target: 0 },     // остывание
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],   // 95% запросов < 500ms
    http_req_failed: ['rate<0.01'],     // ошибок < 1%
  },
};

export default function () {
  // GET-запрос
  const res = http.get('https://api.example.com/users');

  check(res, {
    'status is 200': (r) => r.status === 200,
    'response time < 200ms': (r) => r.timings.duration < 200,
    'has users': (r) => JSON.parse(r.body).length > 0,
  });

  // POST-запрос с данными
  const payload = JSON.stringify({
    name: `User ${__VU}-${__ITER}`,
    email: `user${__VU}@test.ru`
  });

  const postRes = http.post('https://api.example.com/users', payload, {
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer TOKEN'
    },
  });

  check(postRes, { 'created': (r) => r.status === 201 });

  sleep(1);
}

# Запуск
k6 run k6-script.js

# Вывод результатов в Grafana Cloud
k6 run --out cloud k6-script.js

# CI/CD: запуск с порогом ошибок
k6 run --summary-trend-stats="avg,p(95),p(99)" k6-script.js

Нагрузочное тестирование с YAML-конфигурацией. Поддержка HTTP, WebSocket, Socket.io, gRPC.

# artillery-config.yml
config:
  target: "https://api.example.com"
  phases:
    - duration: 60
      arrivalRate: 10     # 10 новых пользователей в секунду
      name: "Warm up"
    - duration: 120
      arrivalRate: 50     # 50 пользователей в секунду
      name: "Peak load"
  defaults:
    headers:
      Authorization: "Bearer {token}"

scenarios:
  - name: "Browse and Order"
    flow:
      - get:
          url: "/api/products"
          capture:
            - json: "$[0].id"
              as: "productId"
      - post:
          url: "/api/orders"
          json:
            product_id: "{ productId }"
            quantity: 1
          expect:
            - statusCode: 201

# Запуск
npx artillery run artillery-config.yml

# Отчёт в HTML
npx artillery run --output report.json artillery-config.yml
npx artillery report report.json

Playwright — не только E2E-тесты UI. Его APIRequestContext — мощный инструмент для тестирования API без браузера.

// tests/api/users.spec.ts
import { test, expect } from '@playwright/test';

test.describe('Users API', () => {
  let apiContext;

  test.beforeAll(async ({ playwright }) => {
    apiContext = await playwright.request.newContext({
      baseURL: 'https://api.example.com',
      extraHTTPHeaders: {
        'Authorization': `Bearer ${process.env.API_TOKEN}`,
        'Content-Type': 'application/json',
      },
    });
  });

  test('GET /users returns list', async () => {
    const response = await apiContext.get('/api/users');
    expect(response.ok()).toBeTruthy();
    expect(response.status()).toBe(200);

    const users = await response.json();
    expect(users.length).toBeGreaterThan(0);
    expect(users[0]).toHaveProperty('id');
    expect(users[0]).toHaveProperty('email');
  });

  test('POST /users creates user', async () => {
    const response = await apiContext.post('/api/users', {
      data: {
        name: 'Тест Тестов',
        email: `test-${Date.now()}@test.ru`
      }
    });

    expect(response.status()).toBe(201);
    const user = await response.json();
    expect(user.name).toBe('Тест Тестов');

    // Проверяем что пользователь реально создан
    const getResponse = await apiContext.get(`/api/users/${user.id}`);
    expect(getResponse.ok()).toBeTruthy();
  });

  test('DELETE /users/:id returns 404 after deletion', async () => {
    // Создаём → удаляем → проверяем
    const created = await apiContext.post('/api/users', {
      data: { name: 'ToDelete', email: 'del@test.ru' }
    });
    const { id } = await created.json();

    const deleted = await apiContext.delete(`/api/users/${id}`);
    expect(deleted.status()).toBe(204);

    const notFound = await apiContext.get(`/api/users/${id}`);
    expect(notFound.status()).toBe(404);
  });
});

# Запуск только API-тестов
npx playwright test tests/api/ --reporter=list

Классическая комбинация для Python-команд. Гибко, расширяемо, огромная экосистема плагинов.

# tests/test_api.py
import pytest
import requests

BASE_URL = "https://api.example.com"

@pytest.fixture(scope="session")
def api_session():
    session = requests.Session()
    session.headers.update({
        "Authorization": f"Bearer {os.environ['API_TOKEN']}",
        "Content-Type": "application/json"
    })
    return session

class TestUsersAPI:
    def test_get_users(self, api_session):
        response = api_session.get(f"{BASE_URL}/api/users")
        assert response.status_code == 200

        users = response.json()
        assert len(users) > 0
        assert "id" in users[0]
        assert "email" in users[0]

    def test_create_user(self, api_session):
        data = {"name": "Pytest User", "email": "pytest@test.ru"}
        response = api_session.post(f"{BASE_URL}/api/users", json=data)
        assert response.status_code == 201

        user = response.json()
        assert user["name"] == "Pytest User"
        return user["id"]

    def test_response_time(self, api_session):
        response = api_session.get(f"{BASE_URL}/api/users")
        assert response.elapsed.total_seconds() < 0.5, \
            f"Response too slow: {response.elapsed.total_seconds()}s"

    @pytest.mark.parametrize("endpoint,expected_status", [
        ("/api/users", 200),
        ("/api/health", 200),
        ("/api/nonexistent", 404),
    ])
    def test_endpoints_status(self, api_session, endpoint, expected_status):
        response = api_session.get(f"{BASE_URL}{endpoint}")
        assert response.status_code == expected_status

# Запуск с отчётом
pytest tests/test_api.py -v --tb=short --junitxml=results.xml

Тестирует API против OpenAPI/Swagger спецификации. Если Swagger описывает один формат, а API возвращает другой — Dredd обнаружит расхождение.

# Установка
npm install -g dredd

# Запуск: проверить API против спецификации
dredd openapi.yaml https://api.example.com

# Результат:
# ✓ GET /users → 200
# ✗ POST /users → expected 201, got 422
# ✓ GET /users/42 → 200
# ✗ DELETE /users/42 → missing response header X-Request-Id

Consumer-driven contract testing. Клиент записывает ожидания (pact), сервер проверяет их. Идеален для микросервисов.

// Consumer-side: что клиент ожидает от API
const { PactV3 } = require('@pact-foundation/pact');

const provider = new PactV3({
  consumer: 'OrderService',
  provider: 'UserService',
});

describe('UserService Pact', () => {
  it('returns user by id', async () => {
    // Описываем ожидание
    provider
      .given('user 42 exists')
      .uponReceiving('a request for user 42')
      .withRequest({
        method: 'GET',
        path: '/api/users/42',
        headers: { Accept: 'application/json' },
      })
      .willRespondWith({
        status: 200,
        headers: { 'Content-Type': 'application/json' },
        body: {
          id: 42,
          name: like('Иван'),     // любая строка
          email: like('ivan@x.ru') // любая строка
        },
      });

    // Проверяем на mock-сервере
    await provider.executeTest(async (mockServer) => {
      const res = await fetch(`${mockServer.url}/api/users/42`);
      const user = await res.json();
      expect(user.id).toBe(42);
    });
  });
});

// Pact-файл сохраняется → передаётся provider-у для проверки