API de correção automática: corrija trabalhos de programação com casos de teste

Also in EnglishTambién en español

Corrija uma submissão numa só requisição

O trabalho: imprimir o maior número de uma linha de números, ou empty quando não há nenhum. Os testes valem 2, 3 e 5 pontos, e o de 5 pontos é oculto. Crie uma chave de API entrando na sua conta e envie o código do aluno com os testes:

curl -X POST https://api.onlinecompiler.io/api/run-tests/ \
  -H "Authorization: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "compiler": "python-3.14",
    "code": "nums = list(map(int, input().split()))\nprint(max(nums))",
    "tests": [
      {"input": "3 9 4\n", "expected_output": "9\n", "weight": 2},
      {"input": "-5 -2 -8\n", "expected_output": "-2\n", "weight": 3},
      {"input": "\n", "expected_output": "empty\n", "weight": 5, "hidden": true}
    ],
    "scoring": "weighted"
  }'

A submissão passa nos dois testes visíveis e quebra na linha vazia oculta, então ganha 5 de 10 pontos. Cada teste rodou no seu próprio sandbox novo:

{
  "verdict": "runtime_error",
  "score": 50.0,
  "passed": 2,
  "total": 3,
  "time_limit": 2,
  "compile_error": null,
  "tests": [
    {"verdict": "accepted", "hidden": false, "time": "0.0204", "memory": "9000",
     "exit_code": 0, "signal": null, "output": "9\n", "error": "", "truncated": false},
    {"verdict": "accepted", "hidden": false, "time": "0.0198", "memory": "9000",
     "exit_code": 0, "signal": null, "output": "-2\n", "error": "", "truncated": false},
    {"verdict": "runtime_error", "hidden": true}
  ]
}

score é a fração dos pontos obtidos. Para registrar pontos em vez de porcentagem, multiplique pelo total do trabalho: 50 × 10 / 100 = 5.

Pontos, nota parcial e testes ocultos

• Pontos: com "scoring": "weighted", o weight de cada teste são os pontos dele. percent conta todos os testes igualmente, e all_or_nothing, o padrão, para na primeira falha.
• Testes ocultos: devolvem só o veredito, então os alunos não conseguem imprimir as entradas ocultas e deixar as respostas fixas no código.
• Comparação da saída: trim, o padrão, ignora espaços no fim das linhas e linhas em branco; tokens ignora todo o espaçamento e as quebras de linha; float aceita números dentro de uma tolerância; exact compara byte a byte.
• Vereditos que os alunos entendem: accepted, wrong_answer, time_limit_exceeded, memory_limit_exceeded, runtime_error e compilation_error, com a saída e os erros do programa nos testes visíveis.
• Tempo limite: 2 segundos por teste por padrão e até 30, então uma solução lenta falha num teste grande como falharia num juiz online.

A lista completa de campos, checkers e vereditos está na referência da API run-tests (em inglês).

Corrija uma pasta de submissões e gere a planilha de notas

Coloque os testes em tests.json (a mesma lista de "tests" acima) e um arquivo por aluno em submissions/. Este script corrige todos os arquivos e grava grades.csv:

import csv, json, pathlib, time
import requests  # pip install requests

API = "https://api.onlinecompiler.io/api/run-tests/"
KEY = "YOUR_API_KEY"
tests = json.loads(pathlib.Path("tests.json").read_text())

with open("grades.csv", "w", newline="") as f:
    grades = csv.writer(f)
    grades.writerow(["student", "verdict", "passed", "score"])
    for path in sorted(pathlib.Path("submissions").glob("*.py")):
        body = {"compiler": "python-3.14", "code": path.read_text(),
                "tests": tests, "scoring": "weighted"}
        while True:
            res = requests.post(API, json=body, headers={"Authorization": KEY}, timeout=90)
            if res.status_code != 429:
                break
            time.sleep(15)  # acima do limite por minuto ou de pendentes: espere e tente de novo
        res.raise_for_status()
        result = res.json()
        grades.writerow([path.stem, result["verdict"],
                         f"{result['passed']}/{result['total']}", result["score"]])

Cada teste conta para o limite de execuções por minuto do seu plano, então o plano define o ritmo: 300 submissões de 10 testes levam pelo menos 100 minutos no Free, 50 no Starter e 25 no Pro. O script espera e tenta de novo quando recebe HTTP 429.

Questionários de programação com correção automática

Ferramentas de formulário e de questionário não rodam código, então as questões de programação nelas acabam virando múltipla escolha do tipo "qual é a saída": o que for i in range(3): print(i * i) imprime? Um aluno que escolhe a opção certa pode ter chutado. Peça o código em vez disso, e corrija rodando o programa:

curl -X POST https://api.onlinecompiler.io/api/run-tests/ \
  -H "Authorization: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "compiler": "python-3.14",
    "code": "n = int(input())\nfor i in range(1, n + 1):\n    print(i * i)",
    "tests": [
      {"input": "3\n", "expected_output": "0\n1\n4\n"},
      {"input": "5\n", "expected_output": "0\n1\n4\n9\n16\n"},
      {"input": "1\n", "expected_output": "0\n", "hidden": true}
    ],
    "scoring": "percent"
  }'

Este aluno começou o laço em 1. Com "scoring": "percent" todos os testes rodam, então a resposta é wrong_answer com nota 0, e cada teste visível devolve o que o programa imprimiu (1, 4 e 9 no primeiro): o aluno vê o erro de off-by-one que a questão de múltipla escolha queria testar. Com range(n), a mesma requisição devolve accepted e nota 100. A página do questionário envia a resposta ao seu servidor, que guarda a chave e os testes e faz a chamada, e um editor incorporado deixa os alunos rodarem o código antes de enviar.

Se os seus questionários estão no Moodle, não há nada para construir: as questões do CodeRunner fazem isso dentro dos questionários do Moodle, e a API hospedada compatível com o Jobe roda essas questões. Veja Moodle CodeRunner sem servidor Jobe.

O GitHub Classroom foi encerrado: para onde vai a correção automática dele

O GitHub desativou o GitHub Classroom em 28 de agosto de 2026. O site e as APIs dele saíram do ar, e os nomes das turmas e das tarefas, os testes definidos fora dos repositórios e as listas de alunos importadas por LTI foram apagados de forma permanente; as contas e os repositórios dos alunos não foram afetados. A página de migração do GitHub recomenda dois substitutos (os links desta seção levam a páginas em inglês):

• Codio é uma plataforma de ensino hospedada, com material de curso, ambientes de programação no navegador, correção automática, login único e envio de notas para o AVA, e detecção de plágio. Os professores têm acesso grátis, e as instituições assinam um contrato pago (veja os preços do Codio).
• Classroom 50 é grátis e open source, da Fifty Foundation. Ele mantém o fluxo de trabalho centrado no GitHub: repositórios das tarefas, comentários no código e correção por GitHub Actions na sua própria organização. Ele exige uma organização no plano Team ou Enterprise do GitHub (grátis para professores verificados pelo GitHub Education), e os minutos do Actions saem da cota da organização: um professor relatou 700 dos 3.000 minutos incluídos gastos depois de uma única tarefa para 150 alunos, com a correção configurada para rodar a cada push.

O OnlineCompiler.io faz um trabalho mais restrito: corrigir o que um programa imprime. Dois caminhos servem para disciplinas que não precisam que os alunos trabalhem em repositórios do GitHub:

• Correção sem contas de aluno no GitHub. Os alunos enviam pelo site do curso ou pelo AVA, e o seu script manda cada submissão para POST /api/run-tests/ com os testes do trabalho. A nota volta na resposta, então não há organização, workflow do Actions nem minutos para vigiar.
• Moodle CodeRunner. Se a sua disciplina já usa o Moodle, aponte o CodeRunner para a API hospedada compatível com o Jobe, sem nada para instalar. Veja Moodle CodeRunner sem servidor Jobe.

Nenhum dos dois traz repositórios, listas de alunos, prazos ou livro de notas; se o fluxo de pull requests é o motivo de você usar o GitHub Classroom, o Classroom 50 é o substituto mais próximo. Se os seus testes eram pares de entrada e saída esperada, cada um vira um teste aqui:

Software de correção automática ou API de correção automática

Um software de correção automática como o CodeGrade e o Codio (sites em inglês) é uma plataforma: ele se conecta ao seu AVA por LTI, pega dele a lista da turma, dá aos alunos tarefas para fazer, corrige as tarefas e devolve as notas para o livro de notas. Os dois também verificam plágio.

O OnlineCompiler.io é só o motor de correção, que você usa a partir dos seus próprios scripts: uma requisição corrige uma submissão, e o site do seu curso, o plugin do AVA ou o script decide quem envia o quê, quando, e para onde vai a nota. Escolha uma plataforma se você quer listas de alunos, envio de notas para o AVA e detecção de plágio sem construir nada. Escolha a API se você já tem um lugar onde os alunos enviam o código, ou se está construindo um.

O que ela não faz

• Listas de alunos, repositórios e prazos: ficam no site do seu curso ou no seu AVA.
• Envio de notas para o AVA: nada é enviado ao Canvas, ao Moodle ou ao Blackboard; o seu código envia a nota.
• Detecção de plágio: compare as submissões com uma ferramenta como o MOSS.
• Pacotes e internet: cada execução tem a biblioteca padrão da linguagem, 512 MB de memória e nenhum acesso à rede. A página de segurança tem os detalhes.

Está construindo algo mais parecido com o LeetCode, com problemas e uma fila de submissões? Veja como criar um juiz online.

Perguntas frequentes

O que é uma API de correção automática de código?

É uma API HTTP que roda o programa de um aluno contra os casos de teste de um trabalho e devolve os resultados, para que o site do seu curso, a sua integração com o AVA (o LMS, como o Moodle) ou o seu script de correção nunca precisem rodar o código dos alunos. A do OnlineCompiler.io devolve um veredito para cada teste, um veredito geral e uma nota de 0 a 100, em 46 linguagens.

Como dou nota parcial?

Dê a cada teste um weight igual aos pontos dele e envie "scoring": "weighted". A nota é a fração dos pontos obtidos, de 0 a 100, então um aluno que passa em testes que valem 5 de 10 pontos tira 50. "percent" conta todos os testes igualmente, e "all_or_nothing" (o padrão) dá 100 ou 0.

Os alunos conseguem ver os testes ocultos?

Não. Um teste oculto volta só com o veredito: sem saída, erro, tempo ou memória que um aluno pudesse usar para descobrir a entrada. Os erros de compilação só voltam quando pelo menos um teste é visível.

Quanto custa corrigir uma disciplina inteira automaticamente?

Cada teste é uma execução. 300 alunos fazendo 30 submissões corrigidas cada, contra 10 testes, mais 50 outras execuções cada, somam 105.000 execuções por mês: o plano Starter, por US$ 10 por mês. Turmas menores cabem nas 100.000 execuções grátis. O estimador da página de preços faz a conta com os seus números.

É um software de correção automática como o CodeGrade ou o Codio?

Não. O CodeGrade e o Codio são plataformas: eles se conectam ao seu AVA por LTI, pegam dele a lista da turma e devolvem as notas para o livro de notas dele. Esta é uma API de correção automática: o site do seu curso ou o seu script envia uma submissão com os testes e recebe de volta os vereditos e uma nota. Listas de alunos, envio de notas ao AVA e detecção de plágio ficam com você.

Substitui a correção automática do GitHub Classroom?

Substitui os testes de entrada e saída: o programa, a entrada, a saída esperada, um tempo limite e os pontos. Não substitui as listas de alunos, os repositórios das tarefas nem os prazos, que ficam no site do seu curso ou no seu AVA.

Dá para rodar testes unitários, como pytest ou JUnit?

Não como frameworks: cada teste compara o que o programa imprime com a saída esperada, e as execuções não instalam pacotes. Para testar uma função, acrescente à submissão um pequeno trecho que chama a função e imprime o resultado, e compare essa saída.