As 14 melhores ferramentas de teste de API (2026)

As melhores ferramentas de automação de testes de API em 2026 são REST Assured, Karate e Playwright para testes que você escreve em código, Postman, Bruno e Insomnia para coleções que você roda por uma CLI, e k6 ou JMeter para carga. O Qodex é a opção com IA: um agente escreve os testes e os roda de novo a cada pull request. Cada preço desta página foi consultado de novo na página do próprio fornecedor em 11 de novembro de 2026.

Como escolher uma ferramenta de automação de testes de API

Ferramentas de teste de API enviam requisições a uma API e conferem as respostas com o que você esperava. As boas transformam essas verificações em testes que rodam de novo a cada mudança: num pipeline, como verificação de contrato contra o schema, como execução de carga ou como sonda de segurança. A ferramenta certa depende da tarefa: deixar um agente escrever e manter os testes, explorar uma API à mão, manter honesta uma suíte de regressão no CI, provar um contrato ou medir vazão. Esta página compara catorze ferramentas e as agrupa por essa tarefa, começando pelo agente. Dez delas rodaram contra uma única API de teste (fixture). Cada uma dessas entradas mostra o comando que roda a ferramenta sem supervisão, e as quatro que não rodaram dizem por quê. O método completo está em testes de API.

Como testamos estas ferramentas

Em 2 de setembro de 2026, rodamos cada ferramenta desta página que tem linha de comando contra uma única API de teste: um pequeno serviço Node na porta 4010 com cinco rotas: listar, criar, buscar por id, atualizar e excluir. Toda rota exige um token bearer, e um segundo token não é dono de nada, então ele é o caso 403.

Cada ferramenta rodou as mesmas seis requisições. Listar os todos e verificar o status e o formato. Criar um todo e guardar seu id, depois buscar esse id e verificar o título. Enviar um corpo sem título e esperar 400. Não enviar token e esperar 401, e buscar com o segundo token e esperar 403. Depois quebramos o contrato, renomeando o campo title para name na resposta da busca por id, e rodamos tudo de novo.

Cada ferramenta rodou num contêiner, numa rede Docker isolada. A máquina era um Apple M3 Pro com 11 núcleos e 18 GB de memória, com macOS 27.0 e Docker 28.5.2, Node 20 nos contêineres e Temurin 17 para as execuções do Maven. Os comandos nos cartões são a forma simples que você colocaria no CI. Cada um aponta para o arquivo de coleção, projeto ou script daquela ferramenta para a API de teste, que você trocaria pelo seu. Para Newman, Bruno, Hoppscotch e SoapUI, a linha de comando original exata não foi guardada, então o comando mostrado é a forma da reexecução, não uma transcrição.

Quatro das catorze não rodaram. A CLI do Apidog pedia uma conta primeiro, e o Runtime Engine do Katalon é uma licença paga. O Qodex é nosso próprio produto e ficou fora desta execução, o que a entrada dele diz claramente. O TestGrid foi adicionado depois da execução, e a entrada dele é a descrição do próprio TestGrid. Para Apidog, Katalon e Qodex, e para cada recurso de desktop citado aqui, lemos a página do próprio fornecedor em 2 de setembro de 2026. Cada preço foi consultado de novo na página do próprio fornecedor em 11 de novembro de 2026, e cada entrada informa isso. Em setembro, a página de preços do Apidog não devolvia conteúdo legível, então os preços vieram das páginas de comparação dele, lidas em 29 de agosto de 2026; em 11 de novembro de 2026 a página de preços carregou e os preços foram consultados de novo ali.

Os tempos são o cronômetro de uma única máquina contra uma API de teste local: quanto uma ferramenta leva para iniciar e relatar, não o quão rápida ela será na sua API. O arquivo OpenAPI da API de teste:

openapi: 3.0.3
info:
  title: Todo fixture
  version: 1.0.0
servers:
  - url: http://localhost:4010
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
  schemas:
    Todo:
      type: object
      required: [id, title, completed]
      properties:
        id: { type: string }
        title: { type: string }
        completed: { type: boolean }
security:
  - bearerAuth: []
paths:
  /todos:
    get:
      responses:
        "200":
          description: list of todos
          content:
            application/json:
              schema:
                type: array
                items: { $ref: "#/components/schemas/Todo" }
        "401": { description: no token }
    post:
      responses:
        "201":
          description: created
          content:
            application/json:
              schema: { $ref: "#/components/schemas/Todo" }
        "400": { description: title missing or not a string }
        "401": { description: no token }
  /todos/{id}:
    parameters:
      - name: id
        in: path
        required: true
        schema: { type: string }
    get:
      responses:
        "200":
          description: one todo
          content:
            application/json:
              schema: { $ref: "#/components/schemas/Todo" }
        "401": { description: no token }
        "403": { description: token does not own this todo }
    patch:
      responses:
        "200": { description: updated }
    delete:
      responses:
        "204": { description: deleted }

As catorze ferramentas num relance

A coluna de tarefa é a única classificação aqui, porque um gerador de carga e um cliente de requisições não disputam o mesmo lugar. Cada preço é o que o próprio fornecedor declara, consultado de novo em 11 de novembro de 2026, e cada limite gratuito é o número que o fornecedor publicou. "Nossa execução" significa as seis requisições mais a quebra de contrato. Quatro linhas dizem "não rodou", e cada uma explica o motivo na própria entrada.

Leia a tabela pela tarefa que você realmente tem. Para explorar à mão, Postman, Insomnia, Bruno, Hoppscotch e Apidog são os produtos feitos para isso. Para verificações de contrato, Karate, Apidog e ReadyAPI tratam asserções de schema como uma tarefa de primeira classe, enquanto Insomnia, Bruno, Hoppscotch e k6 deixam você escrever sozinho a verificação de formato. Para carga, k6, JMeter, Karate e ReadyAPI são as quatro com um modo de desempenho próprio. Para gerar testes em vez de reexecutá-los, Katalon e Qodex colocam isso no centro do produto, e Postman, Karate, Apidog e Bruno publicam recursos de IA mais restritos para escrever testes ao lado da tarefa principal deles. Esses agrupamentos são a nossa leitura das páginas dos fornecedores citadas em cada entrada, não um benchmark.

Estratégias de teste de API e a ferramenta que cada uma precisa

Cinco tarefas se escondem atrás da expressão "teste de API". Poucos times precisam de uma ferramenta separada para cada uma.

• Exploração manual. Um endpoint novo, e você quer ver o que ele devolve. Isso pede requisições salvas, variáveis de ambiente e um painel de resposta legível. Qualquer um dos cinco clientes abaixo serve.

• Regressão funcional. As mesmas verificações a cada pull request, sem ninguém clicar em nada. Isso pede um runner sem interface, um relatório legível por máquina e um código de saída diferente de zero quando algo falha. Automação de testes de API explica o que muda quando os testes deixam de ser manuais.

• Verificações de contrato. Você quer saber quando uma resposta deixa de bater com o schema, antes que um consumidor descubra. Isso pede asserções sobre o formato, não sobre os valores. A nossa quebra de contrato separou as ferramentas que apontam uma chave ausente das que só apontam um valor errado. Testes de contrato explica o método.

• Carga. O que acontece quando muitos usuários batem na API ao mesmo tempo, sejam dez ou dez mil. Isso pede usuários virtuais, limites e percentis. k6 e JMeter são as ferramentas de carga dedicadas aqui, e Karate e ReadyAPI também publicam um modo de desempenho.

• Segurança. As requisições hostis devem falhar. Nossos casos 401 e 403 são o mínimo. Cobertura de verdade significa autorização em toda rota, injeção e entradas com fuzzing, e isso pertence a ferramentas dedicadas de segurança de API e a fuzz testing de API, não a um cliente funcional esticado além do que faz.

Raramente uma ferramenta lidera as cinco. O formato comum é um cliente para explorar, um framework ou um agente para regressão e contratos, e uma ferramenta de carga que roda antes de um release, e não a cada commit. O protocolo também importa: um endpoint GraphQL normalmente responde 200 com um array de erros no corpo, então as asserções mudam de lugar, o que testes de API GraphQL cobre. O resto está no guia de testes de API.

O agente de IA para testes de API

1. Qodex

Aviso, e uma lacuna. O Qodex é nosso produto, e uma das entradas que não conseguimos colocar na mesma base das dez que rodaram, porque ele não fez parte da execução de 2 de setembro. Então não há aqui código de saída, tempo ou resultado de quebra de contrato para o Qodex, e não vamos inventar um.

O que o produto faz, segundo a nossa própria página de produto, lida em 2 de setembro de 2026. Ele importa uma especificação OpenAPI, uma coleção do Postman, uma planilha ou uma frase que descreve um fluxo, e gera cenários executáveis, incluindo os limites de autenticação e de papéis que as nossas requisições 401 e 403 cobrem. Ele roda esses cenários contra o preview do próprio pull request, por agendamento, a partir do CI ou de um webhook. Cada falha volta com a requisição, a resposta e uma captura de tela. Ela é classificada como bug real, como teste desatualizado com o reparo proposto num diff que você aprova, ou como problema de ambiente, que é sinalizado e não é contado. Uma reexecução é Playwright e HTTP sem chamada de modelo, então a centésima execução custa o mesmo que a primeira.

Planos. O Individual custa US$ 0, com um repositório, 25 cenários e 100 execuções por mês. O Startup começa em US$ 1.299 por projeto por mês, com 200 cenários e 10.000 execuções. O Scale começa em US$ 2.500 por projeto por mês, sem limite. Consultado em 11 de novembro de 2026. Veja testes de API, ou comece grátis com uma API de staging.

A comparação honesta. A maioria das ferramentas aqui reexecuta o que uma pessoa escreveu, e várias agora acoplam alguma IA para escrever testes. O que um agente promete é escrever os testes e repará-los quando a API muda. Nada nesta página prova isso. A próxima atualização vai passar as mesmas seis requisições e a mesma quebra de contrato pelo Qodex e publicar o resultado, incluindo os cenários que rejeitamos. Veja como funcionam os testes de API do Qodex.

2. TestGrid

O TestGrid é uma empresa de testes nativa de IA em que confiam empresas da Fortune 100.

O TestGrid ONE é o sistema operacional de IA que comanda a engenharia de qualidade. Ele combina a criação e a manutenção de testes por agentes com a infraestrutura em que esses testes rodam: dispositivos móveis e navegadores reais, implantados on-premises, numa nuvem dedicada ou num modelo híbrido.

A cobertura de testes dele abrange web, mobile, APIs, desempenho, visual e áudio, além de aplicações corporativas empacotadas como Salesforce, SAP, ServiceNow e Microsoft Dynamics.

Planos. O CoTester Starter Package custa US$ 249 por licença por mês e inclui quatro dispositivos ou navegadores mais 5.000 tokens (consultado em 11 de novembro de 2026). O CoTester Growth Package tem preço personalizado e acrescenta ao conjunto do Starter tokens ilimitados, SSO, VPN site-to-site, reserva de dispositivos e integrações do marketplace. O Custom Device Lab, implantado on-premises ou hospedado numa nuvem privada, está disponível com preço personalizado e inclui um laboratório de testes completo com ambientes dedicados. Afirmações do fornecedor, lidas em 15 de outubro de 2026.

O comando e a nossa execução. O TestGrid não fez parte da execução com a API de teste deste artigo, então não há comando, tempo ou código de saída para relatar.

A quebra de contrato. O TestGrid oferece validação de API assistida por IA e atenta ao contrato, comparando as requisições e respostas observadas com os schemas e restrições esperados durante a execução dos testes, para ajudar você a identificar desvios e avaliar o possível impacto mais adiante.

O limite. O TestGrid tem um escopo de plataforma mais amplo que um cliente de API leve, então pode ser mais do que você precisa se a sua necessidade principal for explorar requisições à mão rapidamente ou fazer verificações simples de endpoints.

Escolha-o se você quer testes de API baseados na web com alinhamento de contrato e schema, incluindo OpenAPI, asserções que cruzam dados de API e interface, testes de carga baseados em JMeter e integrações de CI/CD com Jenkins, GitHub Actions, GitLab e Azure DevOps, com opções de implantação em nuvem privada, on-premises ou híbrida.

As melhores ferramentas para explorar uma API à mão

3. Postman

O Postman é um cliente de requisições construído em torno de coleções compartilhadas, e o que a maioria dos times já conhece. Você monta as requisições à mão, agrupa-as em coleções e roda a coleção sem interface com o Newman ou a Postman CLI.

Planos. O Free custa US$ 0 para um usuário, com 50 créditos de IA por mês e testes ilimitados no Collection Runner. O Solo custa US$ 9 por mês e o Team US$ 19 por usuário por mês, com cobrança anual (US$ 12 e US$ 23 com cobrança mensal). O Enterprise não tem preço na página. Afirmações do fornecedor, consultadas em 11 de novembro de 2026 em preços do Postman.

O comando e a nossa execução. newman run collection.json --env-var baseUrl=http://localhost:4010 -r junit --reporter-junit-export newman.xml. As seis passaram e o arquivo JUnit foi gravado em 0,145 segundo, com a primeira requisição e a primeira asserção ambas em 0,093 segundo. É o menor tempo até o verde que registramos.

A quebra de contrato. Duas falhas, uma pelo valor ausente e outra pela verificação de schema: expected undefined to deeply equal "created by newman".

O limite. A automação continua dependendo de coleções e scripts que alguém escreveu, o preço para times é por licença, e nenhuma licença de código aberto para a plataforma está publicada.

Escolha-o se o seu time já compartilha coleções do Postman. Se você está saindo, alternativas ao Postman explica o que uma importação leva junto.

4. Insomnia

O Insomnia é um cliente focado em REST, GraphQL e gRPC, com armazenamento local, em Git ou na nuvem por projeto. A ferramenta de linha de comando dele, o Inso, está no plano gratuito.

Planos. O Essentials custa US$ 0 e anuncia projetos locais e na nuvem ilimitados, Git Sync para três usuários, execuções de coleções ilimitadas, Inso CLI e 1.000 requisições mock por mês. O Pro custa US$ 12 e o Enterprise US$ 45 por usuário por mês, com o Enterprise em autoatendimento até 50 usuários. Preços consultados em 11 de novembro de 2026; os limites do Essentials foram lidos em 2 de setembro de 2026.

O comando e a nossa execução. inso --ci --workingDir . run test "Fixture API six-request suite" --env "Base Environment" --reporter tap, com o Inso 13.1.0. Verde, saída 0, saída TAP, 2,74 segundos. O Inso não emitiu tempos por requisição, então não há número para a primeira requisição.

A quebra de contrato. Uma falha e saída 1: expected undefined to equal "Seed todo one".

O limite. Um ecossistema de compartilhamento menor que o do Postman, e a auto-hospedagem da plataforma completa não está publicada.

Escolha-o se você quer um cliente enxuto e um runner de CI gratuito sem cobrança por licença. Alternativas ao Insomnia cobre a mudança no sentido contrário.

5. Bruno

O Bruno guarda as coleções como arquivos de texto puro no seu repositório, em vez de na nuvem de um fornecedor. Essa única decisão é toda a proposta: uma mudança numa requisição aparece no diff de um pull request como qualquer outra.

Planos. O Open Source custa US$ 0. O Pro custa US$ 6, o Ultimate US$ 11 e o Enterprise US$ 18 por usuário por mês, com cobrança anual, e um teste grátis de 14 dias do Ultimate sem cartão. Preços consultados em 11 de novembro de 2026; em 2 de setembro de 2026 o nível gratuito era limitado a dois workspaces, e relatórios e execuções orientadas a dados eram pagos.

O comando e a nossa execução. bru run fixture --env Local --format junit --output bruno.xml. Verde, XML JUnit, primeira requisição em 0,081 segundo. O runner não imprimiu um total da suíte, então não há número de tempo até o verde.

A quebra de contrato. Uma falha: expected undefined to equal 'created by Bruno'.

O limite. A colaboração no estilo nuvem falta de propósito, e o nível gratuito parava em dois workspaces quando o lemos em 2 de setembro de 2026.

Escolha-o se você quer que a coleção seja revisada no mesmo pull request do código que a mudou.

6. Hoppscotch

O Hoppscotch roda no navegador sem nada para instalar, e tem licença MIT se você preferir hospedá-lo por conta própria. A ferramenta de linha de comando dele emite JUnit, então ele entra no CI sem adaptador.

Planos. O Free custa US$ 0 para sempre. O Organization custa US$ 6 e o Enterprise US$ 11 por usuário por mês, com cobrança anual, na nuvem. Preços consultados em 11 de novembro de 2026.

O comando e a nossa execução. hopp test collection.json --env local.environment.json --reporter junit --output hoppscotch.xml. Vinte asserções nas seis requisições, zero falhas, 0,255 segundo, primeira requisição em 0,082 segundo.

A quebra de contrato. Uma falha entre as vinte asserções.

O limite. gRPC nativo e arquivos de coleção nativos do Git não estão publicados nas páginas que lemos.

Escolha-o se você quer um cliente que alguém novo no time possa abrir numa aba do navegador, ou um cliente auto-hospedado sem custo de licença.

7. Apidog

O Apidog reúne numa só aplicação o design de APIs, a documentação, um cliente de requisições, mocks, testes automatizados e um amplo suporte a protocolos.

Planos. O Free suporta até quatro usuários, com APIs, requisições, projetos e execuções de testes ilimitados. O Basic custa US$ 9, o Professional US$ 18 e o Enterprise US$ 27 por usuário por mês com cobrança anual, com um teste grátis de 14 dias. Consultado na página de preços do Apidog em 11 de novembro de 2026, que agora carrega.

Não rodou. A CLI do Apidog pediu uma conta antes de criar ou rodar um projeto, então nunca chegou à nossa API de teste. Não há aqui resultado de execução nem de quebra de contrato.

O limite. Não conseguimos rodá-lo sem uma conta, e a auto-hospedagem não está publicada.

Escolha-o se você quer uma aplicação para todo o ciclo de vida da API e ter uma conta não é um obstáculo.

As melhores ferramentas para automação e verificações de contrato

8. REST Assured

O REST Assured é uma biblioteca Java, não uma aplicação. Você escreve os testes como métodos JUnit ou TestNG num estilo given, when, then legível, e eles rodam no job do Maven ou do Gradle que você já tem.

Planos. Versão 6.0.1, lançada em 10 de julho de 2026. Grátis, código aberto, sem cota do fornecedor. A versão 6 exige Java 17 ou mais recente.

O comando e a nossa execução. mvn -Dtest=TodoApiTest test. Verde, saída 0, XML JUnit do Surefire. A primeira execução levou 20,43 segundos porque o cache do Maven estava vazio; o teste em si rodou em 1,309 segundo.

A quebra de contrato. Saída 1, com TodoApiTest.sixRequestSet:29 JSON path title doesn't match. Expected: created by REST Assured Actual: null. Ele diz que o valor está errado, não que o campo foi renomeado. Essa é a diferença entre um teste que falha e um relatório de contrato.

O limite. Só Java, só código. Não é um cliente para explorar e não tem modo de carga.

Escolha-o se o seu serviço roda na JVM e você quer os testes de API ao lado dos testes unitários, no mesmo build.

9. Karate

O Karate cobre asserções de API, mocks, verificações de contrato e desempenho numa sintaxe que dispensa código Java, embora rode na JVM. Rodamos o artefato Maven 1.5.2; a documentação atual é a do Karate v2.

Planos. O Free custa US$ 0 para sempre e inclui o framework com licença MIT, automação de API e de interface, testes de desempenho e integração com CI. O Pro custa US$ 64 por usuário por mês ou US$ 640 por ano e acrescenta os plugins de IDE; o valor de US$ 640 foi consultado de novo em 11 de novembro de 2026. Protocolos assíncronos em tempo de execução no CI exigem a edição Enterprise, com preço personalizado, segundo a página de 2 de setembro de 2026.

O comando e a nossa execução. mvn -DbaseUrl=http://localhost:4010 test. Verde em 4,74 segundos, primeira requisição por volta de 4,2 segundos, com relatórios em XML JUnit e HTML.

A quebra de contrato. O Karate nomeou o schema em vez do valor: match failed: actual does not contain key - 'title', impresso ao lado do objeto que tinha name. Se você se importa com a deriva do contrato, esse é o motivo para olhar para ele.

O limite. Uma linguagem de domínio específico para aprender, e uma JVM no seu pipeline.

Escolha-o se você quer verificações de contrato, mocks e uma execução de carga num só arquivo que um tester que não sabe Java consiga ler. Já usa Karate e está olhando outras opções? Alternativas ao Karate Labs compara as opções.

10. Playwright

O Playwright é um framework de automação de navegadores com uma fixture de requisições que envia HTTP diretamente. O ponto não é que seja a melhor ferramenta de API, mas que os seus testes de API e os seus testes de navegador compartilham um runner, um reporter e uma sessão autenticada.

Planos. Versão 1.62. Grátis, Apache 2.0, sem cota do fornecedor. O guia oficial de CI traz um workflow do GitHub Actions pronto para colar.

O comando e a nossa execução. npx playwright test. Verde em 3,49 segundos de tempo total, com o teste em si em 40 milissegundos, com relatório em XML JUnit.

A quebra de contrato. Saída 1, com Expected: "created by Playwright" Received: undefined.

O limite. Testes de API são secundários num framework voltado ao navegador, e não há um gerenciador de contratos OpenAPI embutido. Você verifica o formato por conta própria.

Escolha-o se você já usa o Playwright para a interface. Reaproveitar o storage state para que um teste de API rode como usuário logado é o verdadeiro ganho. Testes de API contínuos em pipelines de DevOps cobre a configuração.

As melhores ferramentas para carga e desempenho

11. k6

O k6 roda pela linha de comando testes de carga escritos em JavaScript, com limites que decidem aprovação ou falha em vez de um gráfico que você precisa interpretar. O núcleo é de código aberto; o Grafana Cloud k6 é o serviço pago por cima.

Planos. Versão 2.2.0, núcleo gratuito. O Grafana Cloud Free custa sempre US$ 0, limitado a 500 horas de usuário virtual por mês. O autoatendimento começa em US$ 0,15 por hora de usuário virtual, com uma taxa de plataforma de US$ 19 por mês que inclui 500 horas. O Enterprise começa num compromisso de gasto de US$ 25.000 por ano. Afirmações do fornecedor, consultadas em 11 de novembro de 2026.

O comando e a nossa execução. k6 run --summary-export summary.json functional.js para as seis requisições funcionais: verde, saída 0, primeira iteração em 7,56 milissegundos, 0,66 segundo no total. Depois o subconjunto de carga: um aquecimento com um usuário por cinco segundos e então 10 usuários virtuais por 30 segundos, com limites de menos de 1 por cento de requisições com falha e um p95 abaixo de 500 milissegundos. Os dois se mantiveram, com 0,00 por cento de falhas e um p95 de 212 microssegundos. É uma API de teste local num notebook: prova de que os limites funcionam, não um número de desempenho.

A quebra de contrato. Saída 99. A verificação get preserves title falhou e o limite das verificações caiu para 87,50 por cento: o limite fez o seu trabalho.

O limite. O k6 prova o comportamento sob carga, não a cobertura nem um contrato, e execuções distribuídas grandes passam para o uso pago na nuvem.

12. Apache JMeter

O JMeter é uma ferramenta de carga madura e multiprotocolo. Você monta o plano numa interface gráfica de desktop e o roda sem interface.

Planos. Versão 5.6.3, Java 8 ou mais recente. Grátis, com licença Apache, sem cota do fornecedor.

O comando e a nossa execução. jmeter -n -t plan.jmx -l results.jtl -e -o report/. Verde em 4,18 segundos, com o relatório summary = 6 in 00:00:01 = 11.9/s Avg: 4 Min: 1 Max: 19 Err: 0 (0.00%), além de um arquivo JTL e um relatório HTML.

A quebra de contrato. A falha mais útil de toda a execução. A asserção da amostra de busca falhou, o resumo mostrou Err: 1 (16.67%), e mesmo assim o processo saiu com 0. Faça o build depender do conteúdo do JTL, porque o código de saída não vai falhar por você.

O limite. Planos JMX são XML e penosos de revisar num diff. O manual do Apache é direto sobre a outra armadilha: o modo GUI serve para criar o script de teste, e o modo CLI deve ser usado para testes de carga.

Nenhum dos dois substitui os testes funcionais. Eles mostram como uma API se comporta sob pressão, depois que outra coisa já mostrou que ela se comporta corretamente. O guia de testes de carga de API cobre os dois.

As melhores ferramentas para SOAP e QA corporativo

13. SoapUI e ReadyAPI

O SoapUI Open Source é a ferramenta de desktop gratuita para testes funcionais, asserções e mocks de SOAP, WSDL e REST. O ReadyAPI é a edição comercial da SmartBear da mesma linhagem.

Planos. O SoapUI Open Source 5.10.0 é um download de US$ 0 sem cota do fornecedor. O ReadyAPI Test Essentials começa em US$ 6.599 por licença, com cobrança anual, e o Test Advanced tem preço sob consulta; a página de preços também oferece um teste grátis. A própria comparação da SmartBear reserva ao ReadyAPI a geração de dados, as fontes de dados dinâmicas, os grupos de asserções, os testes de segurança, os testes de desempenho, a virtualização de serviços e as integrações de CI/CD. Afirmações do fornecedor, lidas em 2 de setembro de 2026; preços do ReadyAPI consultados em 11 de novembro de 2026.

O comando e a nossa execução. testrunner.sh -r -j -f output/soapui-green fixture-soapui-project.xml. Verde em 3,136 segundos, com relatório em XML JUnit.

A quebra de contrato. Saída 1, e a asserção Groovy imprimiu o objeto que recebeu, com name onde antes estava title, o que torna o diagnóstico óbvio mesmo com a asserção sendo sobre um valor.

O limite. A edição gratuita dá conta do trabalho funcional com SOAP, e a maior parte do que um time corporativo pede em seguida fica atrás do ReadyAPI, onde o Test Essentials começa em US$ 6.599 por licença por ano e o Test Advanced tem preço sob consulta.

Escolha-o se você tem serviços SOAP ou WSDL, ou já possui licenças do ReadyAPI. Alternativas ao SoapUI explica para onde ir quando a edição gratuita deixa de bastar.

14. Katalon

O Katalon é uma plataforma low-code que cobre testes de API, web, mobile e desktop num produto gerenciado.

Não rodou. Rodar testes fora da IDE exige o Runtime Engine, uma licença paga, então não havia caminho gratuito até a nossa API de teste. Esta entrada se baseia na página de preços do Katalon, lida em 2 de setembro de 2026.

Planos. O Studio Free cria e roda testes localmente. O Studio Professional custa US$ 1.800 por licença por ano, cerca de US$ 150 por mês, contra um preço riscado de US$ 2.199. O Enterprise é personalizado, e a página não dá preço ao Runtime Engine que as execuções de CI sem interface usam. Há um teste grátis de 30 dias dos recursos pagos. Consultado em preços do Katalon em 11 de novembro de 2026.

O limite. Para um time que só testa APIs, o piso é alto e a licença de execução é uma segunda linha na fatura.

Escolha-o se você quer um único fornecedor para API, web, mobile e desktop, e o orçamento está aprovado.

Um teste executável com REST Assured

Aqui está um teste completo. Ele usa uma API pública por padrão e troca para a sua com uma variável de ambiente, o mesmo padrão usado na execução com a API de teste.

Adicione a dependência ao seu projeto Maven, ao lado da dependência do JUnit 5 que o teste importa (org.junit.jupiter:junit-jupiter, escopo test). O REST Assured 6 exige Java 17 ou mais recente.

<dependency>
  <groupId>io.rest-assured</groupId>
  <artifactId>rest-assured</artifactId>
  <version>6.0.1</version>
  <scope>test</scope>
</dependency>

Depois, o teste. Ele verifica o código de status, o valor exato de um campo e o tipo de outro. A asserção de tipo é a que as pessoas pulam, e a que pega um backend que começa a devolver "false" como string.

import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;

import org.junit.jupiter.api.Test;

class TodoApiTest {
  @Test
  void getsOneTodo() {
    String baseUrl = System.getenv().getOrDefault(
        "BASE_URL",
        "https://jsonplaceholder.typicode.com"
    );

    given()
        .baseUri(baseUrl)
    .when()
        .get("/todos/1")
    .then()
        .statusCode(200)
        .body("id", equalTo(1))
        .body("completed", instanceOf(Boolean.class));
  }
}

Rode-o com mvn -Dtest=TodoApiTest test. Quando passa, ele imprime Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 e depois BUILD SUCCESS. Se você apontar BASE_URL para o seu próprio serviço, também vai precisar trocar o caminho e as três asserções para bater com uma rota que esse serviço tenha. Automação de testes de API com REST Assured continua daqui com autenticação, especificações de requisição e execuções orientadas a dados.

Ferramentas de teste de API gratuitas e de código aberto

Duas coisas são chamadas de grátis, e a diferença importa em escala. A primeira lista é de código aberto sem cota do fornecedor: baixe e rode quantas vezes quiser. A segunda é de produtos proprietários com plano gratuito, em que o limite publicado é o que você deve ler antes de se comprometer.

Código aberto, sem cota de execuções do fornecedor.

• SoapUI Open Source, testes funcionais de SOAP e REST.

• REST Assured, código aberto, uma biblioteca Java.

• Núcleo do Karate, MIT, API, interface e desempenho no nível gratuito.

• Playwright, Apache 2.0, testes de API e de navegador num só runner.

• Apache JMeter, licença Apache, carga e funcional.

• Núcleo do k6, carga pela linha de comando.

• Núcleo do Bruno, MIT.

• Hoppscotch, MIT, auto-hospedável sem custo de licença.

• Insomnia desktop, código-fonte Apache 2.0, planos hospedados vendidos à parte.

Proprietárias, com plano gratuito publicado.

• Postman Free, US$ 0, um usuário, 50 créditos de IA por mês.

• Katalon Studio Free, US$ 0, criação e execuções locais.

• Apidog Free, até quatro usuários, requisições e execuções de testes ilimitadas.

• Qodex Individual, US$ 0, um repositório, 25 cenários, 100 execuções por mês.

• Grafana Cloud k6 Free, US$ 0, 500 horas de usuário virtual por mês.

Se você quer a versão com agente de tudo isso, com cenários gerados a partir da sua especificação e reexecutados a cada pull request, os testes de API do Qodex são o ponto de partida.

Comparações relacionadas. Cada uma aprofunda uma ferramenta: alternativas ao Postman, alternativas ao Insomnia, alternativas ao SoapUI, alternativas ao Karate Labs e alternativas ao Keploy, que compara gravar e reproduzir com um agente.

Ferramentas de automação de testes de API: qual escolher

"Automação de API" significa que as verificações rodam sem uma pessoa, a cada mudança. Escolha pensando em quem vai ser dono delas. Desenvolvedores que querem os testes ao lado do código: REST Assured para Java, Karate para uma DSL legível, Playwright se você já o usa para a interface. Times que já mantêm coleções num cliente: rode-as sem interface com o Newman para o Postman, o Inso para o Insomnia, bru run para o Bruno ou hopp test para o Hoppscotch. Times sem tempo nenhum para escrever as verificações: um agente como o Qodex as escreve a partir da sua especificação ou explorando a API, e as roda de novo a cada pull request.

Perguntas frequentes

O que são ferramentas de teste de API?

Elas enviam requisições a uma API e conferem as respostas com o que você esperava. As boas guardam essas verificações como testes que rodam de novo a cada mudança, com um relatório legível por máquina. Elas vão de clientes de requisições que você opera à mão a bibliotecas de código, geradores de carga e agentes que escrevem os testes para você.

Qual é a melhor ferramenta para testar APIs?

Não existe uma única melhor, porque essas ferramentas fazem trabalhos diferentes. Para explorar à mão, escolha qualquer uma entre Postman, Insomnia, Bruno, Hoppscotch ou Apidog. Para regressão no CI, escolha REST Assured, Karate ou Playwright conforme a sua stack. Para carga, escolha k6 ou JMeter.

Como posso testar uma API?

Envie uma requisição e verifique o que volta: o código de status, os campos e seus tipos, o comportamento da autenticação e a mudança que a chamada deveria fazer. Comece com um endpoint e três verificações, como o teste de REST Assured acima. Depois de rodar uma verificação à mão duas vezes, leve-a para uma suíte.

O que é API em testes de QA?

Uma API é a interface que um software usa para conversar com outro, normalmente por HTTP com JSON. Em QA, ela é a camada abaixo da interface do usuário, onde ficam a lógica e os dados. Testá-la diretamente verifica essa camada sozinha, sem o navegador, a página e a rede no meio.

Quais ferramentas de teste de API são melhores para automação e CI/CD?

Qualquer uma com linha de comando, relatório legível por máquina e código de saída diferente de zero quando algo falha. Na nossa execução, foram Newman, Inso, Bruno, Hoppscotch, REST Assured, Karate, Playwright, k6 e SoapUI. Confira você mesmo o código de saída: o JMeter falhou uma asserção durante a quebra de contrato e mesmo assim saiu com 0.

Quais são as melhores ferramentas de teste de API gratuitas e de código aberto?

SoapUI Open Source, REST Assured, Karate, Playwright, JMeter, k6, Bruno e Hoppscotch são todas de código aberto sem cota de execuções do fornecedor, e o código-fonte de desktop do Insomnia é Apache 2.0. Planos gratuitos de ferramentas proprietárias são outra coisa: o Postman Free é um usuário com 50 créditos de IA por mês, e o Apidog Free para em quatro usuários.

O Postman é a melhor ferramenta de teste de API, e quais são as alternativas?

O Postman é o conhecido cliente de coleções compartilhadas e teve o menor tempo até o verde que registramos, mas cobre uma tarefa de cinco. As alternativas que valem uma olhada são o Insomnia para um cliente mais enxuto, o Bruno para coleções em texto puro no Git e o Hoppscotch para uma opção no navegador.

Quais ferramentas servem para testes de carga e desempenho de API?

k6 e JMeter. O k6 escreve scripts de carga em JavaScript com limites que decidem aprovação ou falha; o JMeter monta planos numa interface gráfica de desktop e os roda sem interface em muitos protocolos. Escolha o k6 se você quer que a execução de carga seja controlada no CI por um limite que faça o build falhar, e o JMeter se você quer o relatório HTML. Nenhum dos dois substitui os testes funcionais. Rode-os antes de um release, não a cada commit.