API REST sobre el
presupuesto del Perú.

🐚 curl (bash · terminal)

curl -X POST https://app.gestionpublicaperu.com.pe/api/insights/query \
  -H "Content-Type: application/json" \
  -d '{
    "sql": "SELECT anio, ROUND(SUM(MTO_PIM)/1e9, 1) AS pim_mil_M FROM mef_historico WHERE SECTOR LIKE \"11%\" GROUP BY anio ORDER BY anio"
  }'

🐍 Python (httpx · ideal para notebooks y scripts)

# pip install httpx polars
import httpx
import polars as pl

resp = httpx.post(
    "https://app.gestionpublicaperu.com.pe/api/insights/query",
    json={
        "sql": """
            SELECT anio,
                   ROUND(SUM(MTO_PIM)/1e9, 1)            AS pim_mil_M,
                   ROUND(SUM(DEVENGADO_)*100
                       / NULLIF(SUM(MTO_PIM),0), 1)      AS avance_pct
            FROM mef_historico
            WHERE PLIEGO LIKE '036%'   -- MTC
            GROUP BY anio
            ORDER BY anio
        """,
        "limit": 9500,   # default del server es 1000; subilo si esperas mas filas
    },
    timeout=60,
)
resp.raise_for_status()

# El response devuelve filas como records (no listas) -> Polars lo carga directo
df = pl.DataFrame(resp.json()["filas"])
print(df)

# Polars es 10-100x mas rapido que pandas en agg/joins. Stack del propio backend.
# Cliente completo con manejo de errores: github.com/sulk1n/gestionpublicaperu-api-clients

🌐 JavaScript (fetch · browser o Node)

const r = await fetch("https://app.gestionpublicaperu.com.pe/api/insights/query", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    sql: `
      SELECT DEPARTAMENTO_META,
             ROUND(SUM(MTO_PIM)/1e6, 1) AS pim_M
      FROM mef_historico
      WHERE anio = 2025 AND DEPARTAMENTO_META != '00 '
      GROUP BY DEPARTAMENTO_META
      ORDER BY pim_M DESC
      LIMIT 5
    `,
  }),
});
const { columnas, filas, n_filas } = await r.json();
console.table(filas);

💠 PowerShell (Invoke-RestMethod · nativo en Windows)

# PowerShell 5.1+ y PowerShell 7 — sin dependencias externas
$body = @{
    sql = @"
SELECT anio,
       ROUND(SUM(MTO_PIM)/1e9, 1)            AS pim_mil_M,
       ROUND(SUM(DEVENGADO_)*100
           / NULLIF(SUM(MTO_PIM),0), 1)      AS avance_pct
FROM mef_historico
WHERE SECTOR LIKE '11%'   -- Salud
GROUP BY anio
ORDER BY anio
"@
    limit = 5000
} | ConvertTo-Json

$resp = Invoke-RestMethod -Uri "https://app.gestionpublicaperu.com.pe/api/insights/query" `
    -Method Post `
    -ContentType "application/json" `
    -Body $body `
    -TimeoutSec 60

# Tabla en consola
$resp.filas | Format-Table -AutoSize

# Exportar a CSV / Excel
$resp.filas | Export-Csv -Path "salud.csv" -NoTypeInformation -Encoding UTF8

# Tip: en PowerShell 7+, usá -SkipHttpErrorCheck para inspeccionar 400/429/504
#      sin que Invoke-RestMethod tire excepción.

Sin instalar nada: Invoke-RestMethod viene con Windows. Ideal para automatizar descargas desde Task Scheduler o pipelines de DevOps. Para POST grandes, usá here-strings (@" ... "@) y ConvertTo-Json.

📊 Excel · Power Query M

// Excel → Datos → Obtener datos → De otras fuentes → Consulta vacía → Editor avanzado
let
    url     = "https://app.gestionpublicaperu.com.pe/api/insights/query",
    sql     = "SELECT anio, ROUND(SUM(MTO_PIM)/1e9, 1) AS pim FROM mef_historico GROUP BY anio ORDER BY anio",
    body    = Json.FromValue([sql = sql]),
    resp    = Web.Contents(url, [
                Content = body,
                Headers = [#"Content-Type" = "application/json"]
              ]),
    json    = Json.Document(resp),
    tabla   = Table.FromRecords(json[filas])
in
    tabla

En Excel: Datos → Obtener datos → De otras fuentes → Consulta vacía → Editor avanzado. Pegá el bloque y refrescá cuando quieras datos nuevos.

// Power BI Desktop → Obtener datos → Consulta en blanco → Editor avanzado
// Credenciales del origen: Anónimo (a nivel de https://app.gestionpublicaperu.com.pe)
let
    url     = "https://app.gestionpublicaperu.com.pe/api/insights/query",
    sql     = "SELECT anio,
                      ROUND(SUM(MTO_PIM)/1e9, 1)                     AS pim_mil_M,
                      ROUND(SUM(DEVENGADO_)/1e9, 1)                  AS dev_mil_M,
                      ROUND(SUM(DEVENGADO_)*100
                          / NULLIF(SUM(MTO_PIM),0), 1)               AS avance_pct
               FROM mef_historico
               GROUP BY anio
               ORDER BY anio",
    body    = Json.FromValue([sql = sql]),
    resp    = Web.Contents(url, [
                Content = body,
                Headers = [#"Content-Type" = "application/json"],
                ManualStatusHandling = {400, 429, 504}
              ]),
    json    = Json.Document(resp),
    tabla   = Table.FromRecords(json[filas]),
    tipada  = Table.TransformColumnTypes(tabla, {
                {"anio",       Int64.Type},
                {"pim_mil_M",  type number},
                {"dev_mil_M",  type number},
                {"avance_pct", type number}
              })
in
    tipada

🐚 curl (bash · terminal)

# Descargar el parquet completo del 2026 (todos las filas, sin cap)
curl -O https://app.gestionpublicaperu.com.pe/api/insights/dump/2026.parquet

# Listar años disponibles + tamaños + fecha de actualización
curl -s https://app.gestionpublicaperu.com.pe/api/insights/dump/manifest.json | jq

# Bajar TODOS los años en paralelo (2013-2026)
for y in $(seq 2013 2026); do
  curl -sO https://app.gestionpublicaperu.com.pe/api/insights/dump/$y.parquet &
done
wait
echo "Total descargado:"
du -sh mef_*.parquet

🐍 Python (streaming + Polars + DuckDB local)

# pip install httpx polars duckdb
import httpx, polars as pl

# Descargar un año
with httpx.stream("GET", "https://app.gestionpublicaperu.com.pe/api/insights/dump/2026.parquet", timeout=120) as r:
    r.raise_for_status()
    with open("mef_2026.parquet", "wb") as f:
        for chunk in r.iter_bytes(chunk_size=1024 * 1024):  # 1 MB chunks
            f.write(chunk)

# Leer directo con Polars — 100× más rápido que pasar por la API HTTP
df = pl.read_parquet("mef_2026.parquet")
print(df.shape, df.columns[:5])

# O queries DuckDB locales sobre el archivo
import duckdb
con = duckdb.connect()
# ⚠️ La columna de año en el parquet raw es ANO_EJE (no 'anio').
# Las columnas 'anio' y 'es_parcial' solo existen en la view DuckDB del backend.
total = con.execute("""
    SELECT SECTOR, ROUND(SUM(MTO_PIM)/1e9, 2) AS pim_mil_M
    FROM 'mef_2026.parquet'
    GROUP BY SECTOR ORDER BY pim_mil_M DESC LIMIT 5
""").fetchall()
print(total)

# Si querés cargar múltiples años en una sola view (replicando mef_historico):
con.execute("""
    CREATE OR REPLACE VIEW mef_local AS
    SELECT
        regexp_extract(filename, 'mef_(\d{4})', 1)::INT AS anio,
        *
    FROM read_parquet('mef_*.parquet', filename=true, union_by_name=true)
""")

httpx.stream usa chunks de 1 MB para no cargar el archivo completo en RAM. Polars lee el parquet en ~1 segundo (vs ~30-60 seg si bajaras las mismas filas como JSON).

💠 PowerShell (descarga paralela)

# PowerShell — descarga directa + tabla nativa
Invoke-WebRequest -Uri "https://app.gestionpublicaperu.com.pe/api/insights/dump/2026.parquet" `
    -OutFile "mef_2026.parquet"

# Listar disponibles
$manifest = Invoke-RestMethod "https://app.gestionpublicaperu.com.pe/api/insights/dump/manifest.json"
$manifest.anios | Format-Table anio, tamano_mb, es_parcial, actualizado -AutoSize

# Loop descargar 2013-2026
2013..2026 | ForEach-Object -Parallel {
    Invoke-WebRequest "https://app.gestionpublicaperu.com.pe/api/insights/dump/$_.parquet" -OutFile "mef_$_.parquet"
} -ThrottleLimit 4

ForEach-Object -Parallel requiere PowerShell 7+. En PS 5.1, usar loop secuencial. -ThrottleLimit 4 evita saturar la red — bajar 14 años en paralelo total son ~1.5 GB.

📈 Power BI · Connector Parquet nativo

// Power BI Desktop — connector Parquet nativo
//
// ⚠️ 2 GOTCHAS importantes:
//   1) Parquet.Document NO acepta stream binario → envolver con Binary.Buffer(...)
//   2) El parquet raw NO tiene la columna 'anio' (es sintética del backend).
//      La columna real del MEF es ANO_EJE (BIGINT).
let
    Source = Parquet.Document(
                Binary.Buffer(                                       // ← gotcha #1
                    Web.Contents("https://app.gestionpublicaperu.com.pe/api/insights/dump/2026.parquet")
                )
              ),
    Tipado = Table.TransformColumnTypes(Source, {
                {"ANO_EJE",    Int64.Type},                          // ← gotcha #2
                {"MTO_PIM",    type number},
                {"DEVENGADO_", type number}
              })
in
    Tipado

// ── Cargar TODOS los años (2013-2026) combinados ──────────────────────
// Sintetizamos la columna 'anio' desde el loop para tener un campo
// uniforme aunque ANO_EJE viniera como string en algún archivo viejo.
let
    Anios       = {2013..2026},
    BajarUno    = (anio as number) as table =>
                    let
                        bin = Binary.Buffer(
                                Web.Contents("https://app.gestionpublicaperu.com.pe/api/insights/dump/" & Number.ToText(anio) & ".parquet")
                              ),
                        tbl = Parquet.Document(bin),
                        conAnio = Table.AddColumn(tbl, "anio", each anio, Int64.Type)
                    in
                        conAnio,
    Tablas      = List.Transform(Anios, each BajarUno(_)),
    Combinado   = Table.Combine(Tablas)
in
    Combinado

// Cuando pida credenciales: Anónimo a nivel de https://app.gestionpublicaperu.com.pe

Mucho más rápido que la query M sobre /query porque Parquet es columnar y comprimido — Power BI solo lee las columnas que usás. Para los 14 años combinados (~1.4 GB descargado), tu modelo final puede quedar en 50-200 MB si solo usás 5-10 columnas.