Calificación automática

API de calificación automática: califica tareas de programación con casos de prueba

La API run-tests de OnlineCompiler.io es un autocalificador que llamas desde tus propias herramientas de curso. Envía la entrega de un estudiante con los casos de prueba de la tarea y recibe un veredicto por prueba y una calificación para dar puntos parciales, mientras que las pruebas ocultas no devuelven nada de lo que un estudiante pueda deducir las entradas. Califica Python, Java, C, C++ y 42 lenguajes más, cada entrega en un sandbox nuevo, y es gratis hasta 100,000 ejecuciones al mes.

Por el equipo de OnlineCompiler.io. Actualizado el .

Also in EnglishTambém em português

Califica una entrega en una sola solicitud

La tarea: imprimir el mayor de una línea de números, o empty cuando no hay ninguno. Las pruebas valen 2, 3 y 5 puntos, y la de 5 puntos es oculta. Obtén una clave de API iniciando sesión y envía el código del estudiante con las pruebas:

Terminal
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"
  }'

La entrega pasa las dos pruebas visibles y falla con la línea vacía oculta, así que obtiene 5 de 10 puntos. Cada prueba se ejecutó en su propio sandbox nuevo:

Respuesta
{
  "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 es la proporción de puntos obtenidos. Para registrar puntos en lugar de un porcentaje, multiplícalo por el total de la tarea: 50 × 10 / 100 = 5.

Puntos, calificación parcial y pruebas ocultas

  • Puntos: con "scoring": "weighted", el weight de cada prueba son sus puntos. percent cuenta todas las pruebas por igual, y all_or_nothing, el valor predeterminado, se detiene en el primer fallo.
  • Pruebas ocultas: devuelven solo su veredicto, así que los estudiantes no pueden imprimir las entradas ocultas y escribir las respuestas fijas en el código.
  • Comparar la salida: trim, el predeterminado, ignora los espacios al final de las líneas y las líneas en blanco; tokens ignora todos los espacios y saltos de línea; float acepta números dentro de una tolerancia; exact compara byte por byte.
  • Veredictos que los estudiantes entienden: accepted, wrong_answer, time_limit_exceeded, memory_limit_exceeded, runtime_error y compilation_error, con la salida y los errores del programa en las pruebas visibles.
  • Tiempos límite: 2 segundos por prueba por defecto y hasta 30, así que una solución lenta falla en una prueba grande como fallaría en un juez en línea.

La lista completa de campos, checkers y veredictos está en la referencia de la API run-tests (en inglés).

Califica una carpeta de entregas y genera la hoja de calificaciones

Pon las pruebas en tests.json (la misma lista que "tests" arriba) y un archivo por estudiante en submissions/. Este script califica todos los archivos y escribe grades.csv:

grade.py
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)  # por encima del límite por minuto o de pendientes: espera y reintenta
        res.raise_for_status()
        result = res.json()
        grades.writerow([path.stem, result["verdict"],
                         f"{result['passed']}/{result['total']}", result["score"]])

Cada prueba cuenta para el límite de ejecuciones por minuto de tu plan, así que el plan marca el ritmo: 300 entregas de 10 pruebas tardan al menos 100 minutos en Free, 50 en Starter y 25 en Pro. El script espera y reintenta cuando recibe HTTP 429.

Cuestionarios de programación con calificación automática

Las herramientas de formularios y cuestionarios no pueden ejecutar código, así que sus preguntas de programación terminan siendo de opción múltiple del tipo "predice la salida": ¿qué imprime for i in range(3): print(i * i)? Un estudiante que elige la opción correcta pudo haber adivinado. Pide el código en su lugar y califícalo ejecutándolo:

Terminal
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 estudiante empezó el ciclo en 1. Con "scoring": "percent" se ejecutan todas las pruebas, así que la respuesta es wrong_answer con una calificación de 0, y cada prueba visible devuelve lo que imprimió el programa (1, 4 y 9 en la primera): el estudiante ve el error por uno (off-by-one) que la pregunta de opción múltiple quería evaluar. Con range(n), la misma solicitud devuelve accepted y una calificación de 100. Tu página de cuestionario envía la respuesta a tu servidor, que guarda la clave y las pruebas y hace la llamada, y un editor incrustado permite a los estudiantes ejecutar su código antes de entregarlo.

Si tus cuestionarios están en Moodle, no hay nada que construir: las preguntas de CodeRunner hacen esto dentro de los cuestionarios de Moodle, y la API alojada compatible con Jobe las ejecuta. Mira Moodle CodeRunner sin servidor Jobe.

GitHub Classroom cerró: a dónde va su calificación automática

GitHub retiró GitHub Classroom el 28 de agosto de 2026. El sitio web y sus API ya no existen, y los nombres de los grupos y las tareas, las pruebas definidas fuera de los repositorios y las listas de estudiantes importadas por LTI se borraron de forma permanente; las cuentas y los repositorios de los estudiantes no se vieron afectados. La página de migración de GitHub recomienda dos reemplazos (los enlaces de esta sección llevan a páginas en inglés):

  • Codio es una plataforma de aprendizaje alojada, con material de curso, entornos de programación en el navegador, calificación automática, inicio de sesión único y envío de calificaciones al LMS, y detección de plagio. Los docentes tienen acceso gratis, y las instituciones firman un acuerdo de pago (consulta los precios de Codio).
  • Classroom 50 es gratis y de código abierto, de la Fifty Foundation. Mantiene el flujo de trabajo centrado en GitHub: repositorios de tareas, comentarios en el código y calificación con GitHub Actions en tu propia organización. Requiere una organización con el plan Team o Enterprise de GitHub (gratis para docentes verificados a través de GitHub Education), y los minutos de Actions corren por cuenta de la organización: un docente reportó 700 de los 3,000 minutos incluidos usados después de una sola tarea para 150 estudiantes, con la calificación configurada para ejecutarse en cada push.

OnlineCompiler.io cubre una tarea más acotada: calificar lo que imprime un programa. Hay dos opciones para cursos que no necesitan que los estudiantes trabajen en repositorios de GitHub:

  • Califica sin cuentas de GitHub para los estudiantes. Los estudiantes entregan a través del sitio de tu curso o de tu LMS, y tu script manda cada entrega a POST /api/run-tests/ con las pruebas de la tarea. La calificación vuelve en la respuesta, así que no hay organización, workflow de Actions ni minutos que vigilar.
  • Moodle CodeRunner. Si tu curso ya funciona en Moodle, apunta CodeRunner a la API alojada compatible con Jobe, sin nada que instalar. Mira Moodle CodeRunner sin servidor Jobe.

Ninguna de las dos te da repositorios, listas de estudiantes, fechas de entrega ni libro de calificaciones; si el flujo de pull requests es la razón por la que usabas GitHub Classroom, Classroom 50 es el reemplazo más cercano. Si tus pruebas eran pares de entrada y salida esperada, cada una se convierte en una prueba aquí:

Prueba de entrada/salida de GitHub ClassroomAPI run-tests
commandcompiler y code: envía el código fuente, no un comando
inputtests[].input
expected-outputtests[].expected_output
comparison-method exactchecker exact, o trim para pasar por alto los espacios al final
comparison-method included o regexNingún checker equivalente: escribe la salida esperada completa, o revisa el output de una prueba visible en tu propio código
timeout (minutos, 10 por defecto)time_limit (segundos, 2 por defecto, hasta 30)
max-scoretests[].weight, con "scoring": "weighted"
setup-commandNinguno: las ejecuciones tienen la biblioteca estándar del lenguaje y no instalan paquetes

Software de calificación automática o API de calificación automática

El software de calificación automática como CodeGrade y Codio (sitios en inglés) es una plataforma: se conecta a tu LMS por LTI, toma de él la lista del grupo, les da a los estudiantes tareas para resolver, las califica y devuelve las calificaciones al libro de calificaciones. Ambos también revisan plagio.

OnlineCompiler.io es solo el motor de calificación, que usas desde tus propios scripts: una solicitud califica una entrega, y el sitio de tu curso, el plugin de tu LMS o tu script deciden quién entrega qué, cuándo y adónde va la calificación. Elige una plataforma si quieres listas de estudiantes, envío de calificaciones al LMS y detección de plagio sin construir nada. Elige la API si ya tienes un lugar donde los estudiantes entregan su código, o si estás construyendo uno.

Lo que no hace

  • Listas de estudiantes, repositorios y fechas de entrega: los guarda el sitio de tu curso o tu LMS.
  • Envío de calificaciones al LMS: nada se publica en Canvas, Moodle ni Blackboard; tu código envía la calificación.
  • Detección de plagio: compara las entregas con una herramienta como MOSS.
  • Paquetes e internet: cada ejecución tiene la biblioteca estándar del lenguaje, 512 MB de memoria y nada de red. La página de seguridad tiene los detalles.

¿Estás construyendo algo más parecido a LeetCode, con problemas y una cola de envíos? Mira cómo crear un juez en línea.

Preguntas frecuentes

¿Qué es una API de calificación automática de código?

Es una API HTTP que ejecuta el programa de un estudiante contra los casos de prueba de una tarea y devuelve los resultados, para que el sitio de tu curso, tu integración con el LMS (como Moodle) o tu script de calificación nunca tengan que ejecutar el código de los estudiantes. La de OnlineCompiler.io devuelve un veredicto por prueba, un veredicto general y una calificación de 0 a 100, en 46 lenguajes.

¿Cómo doy calificación parcial?

Dale a cada prueba un weight igual a sus puntos y envía "scoring": "weighted". La calificación es la proporción de puntos obtenidos, de 0 a 100, así que un estudiante que pasa pruebas que valen 5 de 10 puntos obtiene 50. "percent" cuenta todas las pruebas por igual, y "all_or_nothing" (el valor predeterminado) da 100 o 0.

¿Los estudiantes pueden ver las pruebas ocultas?

No. Una prueba oculta vuelve solo con su veredicto: sin salida, error, tiempo ni memoria de los que un estudiante pudiera deducir la entrada. Los errores de compilación solo se devuelven cuando al menos una prueba es visible.

¿Cuánto cuesta la calificación automática de un curso completo?

Cada prueba es una ejecución. 300 estudiantes que hacen 30 entregas calificadas cada uno contra 10 pruebas, más 50 ejecuciones adicionales cada uno, suman 105,000 ejecuciones al mes: el plan Starter, a US$10 al mes. Los grupos más pequeños caben en las 100,000 ejecuciones gratis. El estimador de la página de precios hace la cuenta con tus números.

¿Es un software de calificación automática como CodeGrade o Codio?

No. CodeGrade y Codio son plataformas: se conectan a tu LMS por LTI, toman de él la lista del grupo y devuelven las calificaciones a su libro de calificaciones. Esta es una API de calificación automática: el sitio de tu curso o tu script manda una entrega con sus pruebas y recibe los veredictos y una calificación. Las listas de estudiantes, el envío de calificaciones al LMS y la detección de plagio quedan de tu lado.

¿Reemplaza la calificación automática de GitHub Classroom?

Reemplaza las pruebas de entrada y salida: el programa, su entrada, la salida esperada, un tiempo límite y los puntos. No reemplaza las listas de estudiantes, los repositorios de tareas ni las fechas de entrega, que siguen en el sitio de tu curso o en tu LMS.

¿Puede ejecutar pruebas unitarias, como pytest o JUnit?

No como frameworks: cada prueba compara lo que imprime el programa con la salida esperada, y las ejecuciones no instalan paquetes. Para probar una función, agrega a la entrega un pequeño fragmento que la llame e imprima el resultado, y compara esa salida.