API Juristeca

1. Introducción

La API Pública Juristeca es un servicio web RESTful desarrollado por el Poder Judicial de la República Dominicana y la Escuela Nacional de la Judicatura que permite a desarrolladores, investigadores e instituciones acceder programáticamente a los recursos jurídicos digitales gestionados a través de la plataforma Juristeca.

A través de esta API es posible realizar búsquedas y consultas sobre cuatro grandes colecciones documentales: boletines judiciales, jurisprudencia, legislación y doctrina jurídica, integrando de forma transparente múltiples fuentes de datos institucionales.

¿Qué puedo consultar?

• Boletines Judiciales: Acceso al boletín judicial mensual actual con enlace al PDF y portada.
• Jurisprudencia: Búsqueda y recuperación de decisiones judiciales con metadatos completos (tribunal, ponente, materia, tipo de decisión, etc.).
• Legislación: Consulta de leyes, decretos y normativas vigentes con datos de publicación en Gaceta Oficial.
• Doctrina: Búsqueda de libros y publicaciones jurídicas con información de autores, editorial y número de páginas.

Audiencia Objetivo

Este manual está dirigido a:

• Desarrolladores de software que deseen integrar datos jurídicos en sus aplicaciones.
• Instituciones públicas y privadas que requieran acceso automatizado a recursos legales.
• Investigadores y académicos en el ámbito del derecho.
• Equipos de TI del Poder Judicial que administren integraciones con esta API.

2. Requisitos Previos

Requisitos Técnicos

1. Conexión a Internet: Necesaria para enviar peticiones HTTP/HTTPS al servidor.
2. Cliente HTTP: Puede utilizar cualquiera de las siguientes opciones:
   • Herramientas gráficas: Postman, Insomnia o similar.
   • Línea de comandos: cURL o HTTPie.
   • Código en cualquier lenguaje: JavaScript, Python, C#, Java, PHP, etc.
   • Navegador web (solo para los endpoints GET).
3. Soporte para JSON: Librería o función nativa para parsear respuestas JSON.
4. Soporte para HTTPS: El servidor únicamente acepta conexiones seguras (TLS).

Software Recomendado para Pruebas

3. URL Base de la API

Todas las rutas descritas en este manual se construyen sobre la siguiente URL base:

Versionado

La versión actual de la API es v1. Todos los endpoints llevan el prefijo api/v1/ para garantizar compatibilidad futura.

4. Autenticación

Control de Acceso por IP

Aunque no hay autenticación, el sistema identifica a cada cliente por su dirección IP (o por el encabezado X-Api-Key si se provee) para aplicar las políticas de límite de uso. Consulte la sección 5. Límites de Uso para más detalles.

5. Límites de Uso

Para garantizar la disponibilidad y el rendimiento del servicio para todos los usuarios, la API aplica un mecanismo de rate limiting basado en el algoritmo Token Bucket.

Configuración del Rate Limiter

Respuesta al Exceder el Límite

Al superar las 100 peticiones por minuto, la API responde con:

// HTTP 429 Too Many Requests
{
                "error": "Ha superado el límite de peticiones permitidas."
}

6. Módulos Disponibles

La API Juristeca está organizada en cuatro módulos temáticos, cada uno con su propio conjunto de endpoints:

Resumen de Endpoints

6.1. Módulo: Boletines Judiciales

El módulo de Boletines permite acceder al Boletín Judicial emitido mensualmente por el Poder Judicial. Devuelve la URL del documento PDF y la imagen de portada correspondientes al mes indicado (o al mes actual si no se especifica fecha).

# Sin parámetro (boletín del mes actual)
GET api/v1/boletines

# Con fecha específica
GET api/v1/boletines?date=2025-03-01

{
                    "pdf": "https://juristeca.edu.do/base/domenj/boletines_judiciales/2025-03/boletin.pdf",
                    "cover": "https://juristeca.edu.do/base/domenj/boletines_judiciales/2025-03/portada.jpg"
}

{
                    "status": 404,
                    "message": "No se pudo encontrar el boletín del mes dado"
}

// Respuesta vacía con código 500 si ocurre un error al obtener el boletín

6.2. Módulo: Jurisprudencia

El módulo de Jurisprudencia proporciona acceso a las decisiones judiciales disponibles en la plataforma Juristeca. Permite tanto la búsqueda por términos como la recuperación de un documento específico mediante su identificador numérico.

{
                    "searchTokens": ["desahucio", "arrendamiento"],
                    "sort": "score desc",
                    "page": 0,
                    "rows": 10
}

{
                    "documentsJurisprudencia": [
    {
                    "id": 10452,
                    "numeroTOL": "TOL-2024-00123",
                    "title": "Sentencia sobre contrato de arrendamiento y desahucio",
                    "materia": ["Civil", "Inmobiliario"],
                    "fecha": "2024-06-15T00:00:00",
                    "numero": "SCJ-2024-0456",
                    "tribunal": "Suprema Corte de Justicia",
                    "tipoDecision": "Sentencia",
                    "accionORecurso": "Casación",
                    "organo": "Primera Cámara Civil",
                    "distritoJudicial": "Distrito Nacional",
                    "ponente": "Magistrado Juan Pérez"
    }
  ]
}

GET api/v1/jurisprudencia/10452

{
                    "status": 404,
                    "message": "No existe documento jurisprudencia con id '10452'"
}

6.3. Módulo: Legislación

El módulo de Legislación permite consultar el cuerpo normativo vigente: leyes, decretos, reglamentos y disposiciones que conforman el ordenamiento jurídico de la República Dominicana, incluyendo datos de publicación en la Gaceta Oficial.

{
                    "searchTokens": ["ley", "notariado"],
                    "sort": "score desc",
                    "page": 0,
                    "rows": 10
}

{
                    "documentsLegislacion": [
    {
                    "id": 3301,
                    "numeroTOL": "TOL-LEG-20240015",
                    "numero": "140-15",
                    "title": "Ley Orgánica del Notariado Dominicano",
                    "fecha": "2015-08-07T00:00:00",
                    "fechaGacetaOficial": "2015-08-21T00:00:00",
                    "entidad": "Congreso Nacional",
                    "ordenamiento": "Derecho Notarial"
    }
  ]
}

GET api/v1/legislacion/3301

{
                    "status": 404,
                    "message": "No existe documento legislación con id '3301'"
}

6.4. Módulo: Doctrina

El módulo de Doctrina ofrece acceso al catálogo de libros y publicaciones jurídicas disponibles en la biblioteca digital Juristeca. Permite buscar por título, autores o editorial, y recuperar la ficha completa de un libro mediante su ISBN.

{
                    "searchTokens": ["derecho penal"],
                    "sort": "score desc",
                    "page": 0,
                    "rows": 10
}

{
                    "doctrinaDocuments": [
    {
                    "id": 801,
                    "title": "Manual de Derecho Penal Dominicano",
                    "editorial": "Ediciones Jurídicas Trajano Potentini",
                    "pages": 648,
                    "authors": [
        {
                    "id": 112,
                    "fullName": "Artagnan Pérez Méndez"
        }
      ]
    }
  ]
}

GET api/v1/doctrina/978-9945-444-00-1

{
                    "status": 404,
                    "message": "No existe documento jurisprudencia con id '978-9945-444-00-1'"
}

11. Parámetros Comunes de Búsqueda

Los tres módulos con capacidad de búsqueda (Jurisprudencia, Legislación y Doctrina) comparten la misma estructura de solicitud. Esta sección detalla cada parámetro con ejemplos prácticos.

Estructura Base del Request Body

{
                "searchTokens": [],         // Lista de términos de búsqueda
                "sort": "score desc",       // Criterio de ordenamiento
                "page": 0,                  // Página (base 0)
                "rows": 10                  // Resultados por página
}

searchTokens — Términos de Búsqueda

Es un arreglo de cadenas de texto. Cada elemento representa un término de búsqueda. El sistema realiza una búsqueda de texto completo considerando todos los términos proporcionados.

sort — Ordenamiento

Define el criterio por el cual se ordenan los resultados devueltos. Valor por defecto: "score desc".

Paginación — page y rows

Use page (base 0) y rows para navegar entre los resultados. La primera página es siempre page: 0.

12. Códigos de Estado HTTP

La API utiliza los siguientes códigos de estado HTTP estándar en sus respuestas:

13. Ejemplos de Integración

A continuación se presentan ejemplos funcionales para integrar la API en los lenguajes de programación más comunes. Reemplace BASE_URL con la URL base real de la API.

13.1 Boletines Judiciales

# Boletín del mes actual
curl -X GET "https://api.poderjudicial.gob.do/Juristeca/api/v1/boletines"

# Boletín de un mes específico
curl -X GET "https://api.poderjudicial.gob.do/Juristeca/api/v1/boletines?date=2025-03-01"

const BASE_URL = 'https://api.poderjudicial.gob.do/Juristeca';

async function obtenerBoletin(fecha = null) {
  const url = new URL(`${BASE_URL}/api/v1/boletines`);
                        if (fecha) url.searchParams.set('date', fecha);

                        const response = await fetch(url.toString());

                        if (!response.ok) {
                        const error = await response.json();
                        throw new Error(error.message ?? `HTTP ${response.status}`);
  }

                        return response.json();
}

// Uso
obtenerBoletin()
  .then(data => {
    console.log('PDF:', data.pdf);
    console.log('Portada:', data.cover);
  })
  .catch(console.error);

obtenerBoletin('2025-03-01').then(console.log).catch(console.error);

import requests

BASE_URL = "https://api.poderjudicial.gob.do/Juristeca"

def obtener_boletin(fecha=None):
    params = {}
                        if fecha:
        params["date"] = fecha

    response = requests.get(f"{BASE_URL}/api/v1/boletines", params=params)
    response.raise_for_status()
                        return response.json()

# Uso
boletin = obtener_boletin()
print("PDF:", boletin["pdf"])
print("Portada:", boletin["cover"])

boletin_marzo = obtener_boletin("2025-03-01")
print(boletin_marzo)

using System.Net.Http.Json;

const string BASE_URL = "https://api.poderjudicial.gob.do/Juristeca";

async Task<BoletinDto?> ObtenerBoletin(DateTime? fecha = null)
{
                        using var client = new HttpClient();
                        var url = $"{BASE_URL}/api/v1/boletines";
                        if (fecha.HasValue)
        url += $"?date={fecha.Value:yyyy-MM-dd}";

                        var response = await client.GetAsync(url);
    response.EnsureSuccessStatusCode();
                        return await response.Content.ReadFromJsonAsync<BoletinDto>();
}

// Modelo
record BoletinDto(string? Pdf, string? Cover);

// Uso
var boletin = await ObtenerBoletin();
Console.WriteLine($"PDF: {boletin?.Pdf}");

13.2 Búsqueda de Jurisprudencia

# Búsqueda por términos
curl -X POST "https://api.poderjudicial.gob.do/Juristeca/api/v1/jurisprudencia/search" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTokens": ["desahucio", "arrendamiento"],
    "sort": "score desc",
    "page": 0,
    "rows": 10
  }'

# Obtener documento por ID
curl -X GET "https://api.poderjudicial.gob.do/Juristeca/api/v1/jurisprudencia/10452"

const BASE_URL = 'https://api.poderjudicial.gob.do/Juristeca';

async function buscarJurisprudencia({ terminos = [], pagina = 0, filas = 10, orden = 'score desc' } = {}) {
                        const response = await fetch(`${BASE_URL}/api/v1/jurisprudencia/search`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      searchTokens: terminos,
      sort: orden,
      page: pagina,
      rows: filas
    })
  });

                        if (!response.ok) throw new Error(`HTTP ${response.status}`);
                        return response.json();
}

async function obtenerJurisprudencia(id) {
                        const response = await fetch(`${BASE_URL}/api/v1/jurisprudencia/${id}`);
                        if (!response.ok) throw new Error(`HTTP ${response.status}`);
                        return response.json();
}

// Uso
buscarJurisprudencia({ terminos: ['desahucio'], pagina: 0, filas: 5 })
  .then(data => data.documentsJurisprudencia.forEach(d => console.log(d.title)));

obtenerJurisprudencia(10452).then(console.log);

import requests

BASE_URL = "https://api.poderjudicial.gob.do/Juristeca"

def buscar_jurisprudencia(terminos=None, pagina=0, filas=10, orden="score desc"):
    payload = {
                        "searchTokens": terminos or [],
                        "sort": orden,
                        "page": pagina,
                        "rows": filas
    }
    response = requests.post(
                        f"{BASE_URL}/api/v1/jurisprudencia/search",
        json=payload
    )
    response.raise_for_status()
                        return response.json()

def obtener_jurisprudencia(id_doc):
    response = requests.get(f"{BASE_URL}/api/v1/jurisprudencia/{id_doc}")
    response.raise_for_status()
                        return response.json()

# Búsqueda
resultados = buscar_jurisprudencia(["desahucio", "arrendamiento"])
for doc in resultados["documentsJurisprudencia"]:
    print(doc["title"], "-", doc.get("tribunal"))

# Por ID
documento = obtener_jurisprudencia(10452)
print(documento)

using System.Net.Http.Json;

const string BASE_URL = "https://api.poderjudicial.gob.do/Juristeca";
using var client = new HttpClient();

// Búsqueda
var request = new {
    searchTokens = new[] { "desahucio", "arrendamiento" },
    sort = "score desc",
    page = 0,
    rows = 10
};

var searchResp = await client.PostAsJsonAsync(
                        $"{BASE_URL}/api/v1/jurisprudencia/search", request);
searchResp.EnsureSuccessStatusCode();

var resultados = await searchResp.Content
    .ReadFromJsonAsync<JurisprudenciaDto>();

foreach (var doc in resultados?.DocumentsJurisprudencia ?? [])
    Console.WriteLine($"{doc.Title} - {doc.Tribunal}");

// Por ID
var getResp = await client.GetAsync($"{BASE_URL}/api/v1/jurisprudencia/10452");
getResp.EnsureSuccessStatusCode();

13.3 Búsqueda de Legislación

curl -X POST "https://api.poderjudicial.gob.do/Juristeca/api/v1/legislacion/search" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTokens": ["ley", "notariado"],
    "sort": "score desc",
    "page": 0,
    "rows": 10
  }'

# Por ID
curl -X GET "https://api.poderjudicial.gob.do/Juristeca/api/v1/legislacion/3301"

async function buscarLegislacion(terminos, pagina = 0, filas = 10) {
                        const response = await fetch(`${BASE_URL}/api/v1/legislacion/search`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ searchTokens: terminos, sort: 'score desc', page: pagina, rows: filas })
  });
                        if (!response.ok) throw new Error(`HTTP ${response.status}`);
                        return response.json();
}

buscarLegislacion(['ley', 'notariado'])
  .then(data => data.documentsLegislacion.forEach(l => console.log(l.numero, l.title)));

def buscar_legislacion(terminos, pagina=0, filas=10):
    response = requests.post(
                        f"{BASE_URL}/api/v1/legislacion/search",
        json={"searchTokens": terminos, "sort": "score desc",
                        "page": pagina, "rows": filas}
    )
    response.raise_for_status()
                        return response.json()

leyes = buscar_legislacion(["ley", "notariado"])
for ley in leyes["documentsLegislacion"]:
    print(ley["numero"], "-", ley["title"])

13.4 Búsqueda de Doctrina

curl -X POST "https://api.poderjudicial.gob.do/Juristeca/api/v1/doctrina/search" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTokens": ["derecho penal"],
    "sort": "score desc",
    "page": 0,
    "rows": 10
  }'

# Por ISBN
curl -X GET "https://api.poderjudicial.gob.do/Juristeca/api/v1/doctrina/978-9945-444-00-1"

async function buscarDoctrina(terminos, pagina = 0, filas = 10) {
                        const response = await fetch(`${BASE_URL}/api/v1/doctrina/search`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ searchTokens: terminos, sort: 'score desc', page: pagina, rows: filas })
  });
                        if (!response.ok) throw new Error(`HTTP ${response.status}`);
                        return response.json();
}

buscarDoctrina(['derecho penal'])
  .then(data => data.doctrinaDocuments.forEach(d => {
                        const autores = d.authors.map(a => a.fullName).join(', ');
    console.log(`${d.title} — ${autores}`);
  }));

def buscar_doctrina(terminos, pagina=0, filas=10):
    response = requests.post(
                        f"{BASE_URL}/api/v1/doctrina/search",
        json={"searchTokens": terminos, "sort": "score desc",
                        "page": pagina, "rows": filas}
    )
    response.raise_for_status()
                        return response.json()

def obtener_doctrina_por_isbn(isbn):
    response = requests.get(f"{BASE_URL}/api/v1/doctrina/{isbn}")
    response.raise_for_status()
                        return response.json()

libros = buscar_doctrina(["derecho penal"])
for libro in libros["doctrinaDocuments"]:
    autores = ", ".join(a["fullName"] for a in libro["authors"])
    print(f'{libro["title"]} — {autores}')

14. Manejo de Errores

Esta sección describe las causas y soluciones para cada tipo de error que puede retornar la API, junto con estrategias para un manejo robusto en sus aplicaciones.

400 — Bad Request

// Incorrecto: rows como string
{ "searchTokens": ["civil"], "rows": "diez" }

// Correcto: rows como integer
{ "searchTokens": ["civil"], "rows": 10 }

404 — Not Found

{
                    "status": 404,
                    "message": "No existe documento jurisprudencia con id '99999'"
}

429 — Too Many Requests

{
                    "error": "Ha superado el límite de peticiones permitidas."
}

async function fetchConReintento(url, opciones, maxIntentos = 3) {
                    for (let intento = 1; intento <= maxIntentos; intento++) {
                    const response = await fetch(url, opciones);
                    if (response.status !== 429) return response;
                    const espera = Math.pow(2, intento) * 1000;
    console.warn(`Rate limit. Reintentando en ${espera}ms...`);
                    await new Promise(r => setTimeout(r, espera));
  }
                    throw new Error('Máximo de reintentos alcanzado');
}

500 — Internal Server Error

Buenas Prácticas de Manejo de Errores

• Siempre valide el código de estado HTTP antes de procesar la respuesta.
• Lea el cuerpo del mensaje de error para presentar información útil al usuario.
• Implemente lógica de reintento exclusivamente para errores 429 y 500 (no para 400/404).
• Registre los errores con contexto (URL, parámetros, timestamp) para facilitar la depuración.
• Informe al usuario final con mensajes claros y en español, sin exponer detalles técnicos.
• Implemente cache para reducir el número de peticiones y evitar el error 429.

Anexo: Glosario de Términos