¿A cuánto está el dólar hoy? En Perú casi todo el mundo se lo pregunta en algún momento: quien importa, quien ahorra en dólares o quien paga un curso en línea. En este artículo cuento cómo construí una solución de ingeniería de datos de punta a punta. Descarga cada día el tipo de cambio oficial del Banco Central de Reserva del Perú (BCRP), lo transforma con dbt sobre DuckDB y lo publica en un dashboard público. Todo es automático, con herramientas gratuitas y sin AWS.
📊 Dashboard en vivo: https://tipo-cambio-peru.streamlit.app
💻 Repositorio: https://github.com/JhonyVargas/pipeline-tipo-cambio-peru
🎥 Video (4 min): https://youtu.be/nXBJtwl8tdw
🎯 El problema
El BCRP publica el tipo de cambio interbancario en su API de series estadísticas, pero los datos no vienen listos para analizar. Esta es una respuesta real de la API:
"periods": [
{ "name": "10.Nov.26", "values": ["3.41371428571429", "3.41621428571429"] },
{ "name": "11.Nov.26", "values": ["3.40914285714286", "3.41085714285714"] }
]
- Las fechas son texto con meses en español abreviados (
10.Nov.26). - Los valores son texto con 14 decimales.
- Los días sin cotización aparecen como
n.d.(no disponible).
El objetivo era una solución que:
- Extraiga los datos automáticamente cada día hábil.
- Los limpie y transforme con pruebas de calidad.
- Los publique en un dashboard abierto a cualquiera.
- Cueste S/ 0 y no use AWS.
🏗️ Arquitectura
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌───────────────┐ ┌─────────┐ ┌───────────┐
│ API BCRP │ → │ Python │ → │ DuckDB │ → │ dbt │ → │ Parquet │ → │ Streamlit │
│ (fuente) │ │ Extract │ │ raw │ │ staging/marts │ │ /data │ │ Dashboard │
└──────────┘ └──────────┘ └──────────┘ └───────────────┘ └─────────┘ └───────────┘
▲
└──── GitHub Actions (lunes a viernes, 09:00 hora de Lima)
| Capa | Herramienta | Por qué la elegí |
|---|---|---|
| Extracción y carga | Python | Bastan urllib y duckdb, sin librerías pesadas |
| Almacenamiento | DuckDB | Data warehouse analítico en un solo archivo, sin servidor |
| Transformación | dbt + dbt-duckdb
|
SQL versionado, modelos por capas y tests de calidad |
| Orquestación | GitHub Actions | Ejecuciones programadas gratis en repositorios públicos |
| Visualización | Streamlit + Plotly | Dashboard 100 % Python con hosting gratuito |
Es un enfoque ELT, no ETL: primero se cargan los datos crudos en el warehouse y la transformación ocurre dentro de él, con dbt. Así, si cambia una regla de limpieza, basta con volver a ejecutar dbt sobre los datos crudos.
1️⃣ Extraer y cargar con Python
El script pipeline/extract.py pide dos series al BCRP: PD04637PD (compra) y PD04638PD (venta), desde 2015 hasta hoy.
SERIES = "PD04637PD-PD04638PD" # compra - venta
URL = "https://estadisticas.bcrp.gob.pe/estadisticas/series/api/{series}/json/{ini}/{fin}"
def extraer() -> list[dict]:
url = URL.format(series=SERIES, ini=FECHA_INICIO, fin=date.today().isoformat())
req = urllib.request.Request(url, headers={"User-Agent": "data-pipeline-tc/1.0"})
with urllib.request.urlopen(req, timeout=60) as resp:
payload = json.loads(resp.read().decode("utf-8-sig"))
return [
{"periodo": p["name"], "compra": p["values"][0], "venta": p["values"][1]}
for p in payload["periods"]
]
Los datos se cargan tal cual llegan en una tabla raw, todo como VARCHAR. Este paso no limpia nada a propósito; eso le toca a dbt.
con = duckdb.connect("warehouse/tipo_cambio.duckdb")
con.execute("CREATE SCHEMA IF NOT EXISTS raw")
con.execute("""
CREATE OR REPLACE TABLE raw.tipo_cambio_bcrp (
periodo VARCHAR, -- formato BCRP: '02.Ene.20'
compra VARCHAR, -- texto, puede venir 'n.d.'
venta VARCHAR,
cargado_en TIMESTAMP
)
""")
con.executemany("INSERT INTO raw.tipo_cambio_bcrp VALUES (?, ?, ?, ?)", filas)
Cada ejecución recarga la tabla completa con CREATE OR REPLACE. Son unos 3 100 registros, así que es muy rápido, y siempre da el mismo resultado, se ejecute las veces que se ejecute.
2️⃣ Transformar con dbt
Esta es la estructura del proyecto dbt:
dbt_tipo_cambio/
├── dbt_project.yml
├── profiles.yml
├── models/
│ ├── staging/
│ │ ├── _sources.yml
│ │ └── stg_tipo_cambio.sql
│ ├── marts/
│ │ ├── fct_tipo_cambio_diario.sql
│ │ ├── fct_tipo_cambio_mensual.sql
│ │ └── fct_tipo_cambio_anual.sql
│ └── schema.yml
└── tests/
├── assert_tipo_cambio_en_rango.sql
└── assert_venta_mayor_o_igual_compra.sql
La conexión a DuckDB es mínima gracias al adaptador dbt-duckdb:
# profiles.yml
tipo_cambio:
target: dev
outputs:
dev:
type: duckdb
path: "{{ env_var('DUCKDB_PATH', 'warehouse/tipo_cambio.duckdb') }}"
threads: 2
Hay dos capas: staging, que se crea como vista, y marts, que se crea como tabla.
# dbt_project.yml
models:
tipo_cambio:
staging:
+schema: staging
+materialized: view
marts:
+schema: marts
+materialized: table
Staging: de texto a datos limpios
stg_tipo_cambio separa la fecha '02.Ene.20' en día, mes y año y la convierte a DATE. try_cast convierte 'n.d.' en NULL, y esos días se descartan. Esta es una versión resumida:
with partes as (
select
cast(split_part(periodo, '.', 1) as integer) as dia,
lower(split_part(periodo, '.', 2)) as mes_txt,
2000 + cast(split_part(periodo, '.', 3) as integer) as anio,
try_cast(compra as double) as tc_compra,
try_cast(venta as double) as tc_venta
from {{ source('bcrp', 'tipo_cambio_bcrp') }}
)
select
make_date(anio,
case mes_txt
when 'ene' then 1 when 'feb' then 2 when 'mar' then 3
when 'abr' then 4 when 'may' then 5 when 'jun' then 6
when 'jul' then 7 when 'ago' then 8 when 'set' then 9
when 'sep' then 9 when 'oct' then 10 when 'nov' then 11
when 'dic' then 12
end,
dia) as fecha,
round(tc_compra, 4) as tc_compra,
round(tc_venta, 4) as tc_venta
from partes
where tc_compra is not null
and tc_venta is not null
Marts: métricas para el análisis
fct_tipo_cambio_diario usa funciones de ventana para calcular la variación diaria y las medias móviles:
select
fecha,
tc_compra,
tc_venta,
round(tc_venta - tc_compra, 4) as spread,
round((tc_venta / lag(tc_venta) over (order by fecha) - 1) * 100, 4) as var_diaria_pct,
round(avg(tc_venta) over (
order by fecha rows between 6 preceding and current row), 4) as media_movil_7d,
round(avg(tc_venta) over (
order by fecha rows between 29 preceding and current row), 4) as media_movil_30d
from {{ ref('stg_tipo_cambio') }}
fct_tipo_cambio_mensual arma las velas mensuales: apertura, máximo, mínimo y cierre. DuckDB tiene dos funciones muy útiles para esto: arg_min y arg_max. Por ejemplo, arg_min(tc_venta, fecha) devuelve el tc_venta del día con la fecha más temprana.
select
date_trunc('month', fecha)::date as periodo,
arg_min(tc_venta, fecha) as apertura,
arg_max(tc_venta, fecha) as cierre,
max(tc_venta) as maximo,
min(tc_venta) as minimo,
round(stddev_samp(var_diaria_pct), 4) as volatilidad_pct
from {{ ref('fct_tipo_cambio_diario') }}
group by 1
Tests de calidad: 13 en total
En schema.yml hay 11 tests genéricos (unique y not_null) sobre las claves de cada modelo y de la fuente. Además hay dos tests propios en SQL. El primero es un rango razonable: si el dólar sale por debajo de S/ 2.5 o por encima de S/ 5.0, casi seguro es un error de la fuente.
-- tests/assert_tipo_cambio_en_rango.sql
select * from {{ ref('fct_tipo_cambio_diario') }}
where tc_venta not between 2.5 and 5.0
or tc_compra not between 2.5 and 5.0
El segundo es una regla de negocio: el precio de venta no debería ser menor que el de compra.
-- tests/assert_venta_mayor_o_igual_compra.sql
{{ config(severity='warn') }}
select * from {{ ref('fct_tipo_cambio_diario') }}
where tc_venta < tc_compra
Este test está configurado como advertencia y no como error. Al revisar los datos encontré que el propio BCRP tiene 5 días históricos en los que la venta es menor que la compra, con diferencias menores a un céntimo. Como error, ese test detendría el pipeline todos los días por un problema histórico que no puedo corregir. Como advertencia, la anomalía queda registrada y los datos se siguen actualizando.
Esta es la salida real de dbt build en GitHub Actions:
Found 4 models, 13 data tests, 1 source, 470 macros
...
Completed with 1 warning:
Done. PASS=16 WARN=1 ERROR=0 SKIP=0 NO-OP=0 REUSED=0 TOTAL=17
3️⃣ Exportar a Parquet
El archivo de DuckDB se regenera en cada ejecución y no se sube al repositorio. Lo que sí se sube son 3 archivos Parquet que suman unos 185 KB, uno por cada mart, más un metadata.json con la fecha de actualización.
for tabla in ["fct_tipo_cambio_diario", "fct_tipo_cambio_mensual", "fct_tipo_cambio_anual"]:
con.execute(f"COPY (SELECT * FROM main_marts.{tabla}) TO 'data/{tabla}.parquet' (FORMAT PARQUET)")
Gracias a esto, el dashboard no necesita una base de datos, un servidor ni credenciales: lee archivos que ya están en el repositorio.
4️⃣ Orquestar con GitHub Actions
Un pequeño orquestador, pipeline/run_all.py, ejecuta los tres pasos en orden. Si alguno falla, se detiene. Es el mismo comando en local y en la nube:
paso("1. Extract + Load (API BCRP -> DuckDB)", [py, "pipeline/extract.py"])
paso("2. Transform + Test (dbt build)", dbt + ["build"] + flags)
paso("3. Export (marts -> Parquet)", [py, "pipeline/export.py"])
Y este es el workflow que lo ejecuta todos los días (versión resumida):
name: Pipeline ELT - Tipo de cambio
on:
schedule:
- cron: "0 14 * * 1-5" # lunes a viernes, 09:00 hora de Lima (14:00 UTC)
workflow_dispatch: # botón para ejecutarlo manualmente
permissions:
contents: write # necesario para hacer commit de los datos
jobs:
elt:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: actions/setup-python@v7
with:
python-version: "3.12"
cache: pip
- run: pip install -r requirements-pipeline.txt
- run: python pipeline/run_all.py
- name: Publicar datos actualizados (commit automático)
run: |
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git add data/
if git diff --staged --quiet; then
echo "Sin cambios en los datos."
else
git commit -m "data: actualización automática $(date -u +'%Y-%m-%d %H:%M') UTC [skip ci]"
git push
fi
La ejecución completa tarda menos de un minuto. Además, guarda la documentación generada por dbt como artefacto de la ejecución.
5️⃣ Dashboard con Streamlit
El dashboard lee los Parquet con DuckDB y los guarda en caché durante una hora:
@st.cache_data(ttl=3600)
def cargar():
con = duckdb.connect()
q = lambda t: con.execute(f"SELECT * FROM read_parquet('{(DATA / t).as_posix()}.parquet')").df()
diario, mensual, anual = q("fct_tipo_cambio_diario"), q("fct_tipo_cambio_mensual"), q("fct_tipo_cambio_anual")
meta = json.loads((DATA / "metadata.json").read_text(encoding="utf-8"))
return diario, mensual, anual, meta
Esto es lo que incluye:
- Indicadores: compra y venta del último día, promedio del mes, variación del año y rango de las últimas 52 semanas.
- Evolución: la serie histórica con filtros de 1 mes a todo el histórico, y medias móviles.
- Análisis mensual: velas mensuales (naranja si el dólar subió, azul si bajó) y la variación de cada mes.
- Volatilidad: por año, con la distribución de las variaciones diarias.
- Datos: la tabla completa, descargable en CSV.
- Conversor de dólares a soles y de soles a dólares con el tipo de cambio del día.
6️⃣ Publicar en Streamlit Community Cloud
- Entra en share.streamlit.io con tu cuenta de GitHub.
-
Create app → elige el repositorio, la rama
mainy el archivoapp/streamlit_app.py. - Elige una URL personalizada, por ejemplo
tipo-cambio-peru. - En Advanced settings, elige Python 3.12.
- Pulsa Deploy.
⚠️ Un detalle que me pasó: la versión de Python que venía por defecto era 3.14, pero las versiones que fijé de duckdb (1.3.2) y pandas (2.2.3) no tienen paquetes precompilados para 3.14, así que la instalación habría fallado. Usar la misma versión de Python que en GitHub Actions evita sorpresas.
Así queda cerrado el ciclo de despliegue automático:
GitHub Actions (cron) → descarga y transforma → commit de /data → Streamlit Cloud detecta el commit → dashboard actualizado
Nadie tiene que tocar nada. El dashboard se actualiza solo cada día hábil.
📈 Resultados
- 3 097 registros descargados de la API del BCRP.
- 2 956 días hábiles válidos, de enero de 2015 a hoy, resumidos en 143 meses y 12 años.
- 13 tests de calidad en cada ejecución.
- Pipeline completo en menos de 1 minuto.
- Costo de infraestructura: S/ 0.
💡 Lo que aprendí
- Cargar los datos crudos tal cual (ELT) permite volver a procesarlo todo cuando cambia una regla, sin tener que pedir los datos otra vez a la fuente.
- No todo test debe detener el pipeline. Si la fuente tiene anomalías históricas que no puedes corregir, una advertencia documentada es más honesta y más útil que un error permanente.
- DuckDB alcanza para mucho. Para miles o incluso millones de filas, un warehouse en un solo archivo evita tener que administrar servidores.
- El cron de GitHub Actions no es puntual. Programé las 14:00 UTC y en la práctica las ejecuciones empezaron entre las 20:40 y las 21:10 UTC. Para datos diarios no importa, pero hay que saberlo.
- Fija las versiones de Python y de las librerías, y usa las mismas en todos los entornos.
▶️ Pruébalo tú
git clone https://github.com/JhonyVargas/pipeline-tipo-cambio-peru.git
cd pipeline-tipo-cambio-peru
pip install -r requirements-pipeline.txt -r requirements.txt
python pipeline/run_all.py # ejecuta todo el pipeline
streamlit run app/streamlit_app.py # abre el dashboard
🎥 Video
🔗 Enlaces
- 📊 Dashboard: https://tipo-cambio-peru.streamlit.app
- 💻 Repositorio: https://github.com/JhonyVargas/pipeline-tipo-cambio-peru
- 🎥 Video: https://youtu.be/nXBJtwl8tdw
- 🏦 Fuente de datos: BCRP, API de Series Estadísticas
JhonyVargas
/
pipeline-tipo-cambio-peru
Pipeline ELT del tipo de cambio USD/PEN con Python, DuckDB, dbt, GitHub Actions y Streamlit
💱 Pipeline de Tipo de Cambio USD/PEN
Solución de ingeniería de datos que extrae automáticamente el tipo de cambio interbancario publicado por el Banco Central de Reserva del Perú (BCRP), lo transforma con dbt sobre DuckDB y lo publica en un dashboard interactivo en Streamlit Community Cloud.
🔗 Dashboard en vivo: https://tipo-cambio-peru.streamlit.app
🏗️ Arquitectura
┌────────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────┐ ┌─────────┐ ┌────────────┐
│ API BCRP │ → │ Python │ → │ DuckDB │ → │ dbt │ → │ Parquet │ → │ Streamlit │
│ (fuente) │ │ Extract │ │ raw │ │ staging/marts│ │ /data │ │ Dashboard │
└────────────┘ └──────────┘ └──────────┘ └──────────────┘ └─────────┘ └────────────┘
▲
└──── GitHub Actions (cron lunes a viernes 09:00 Lima)
| Capa | Herramienta | Descripción |
|---|---|---|
| Extract + Load | Python | Descarga la serie del BCRP y la guarda cruda en raw.tipo_cambio_bcrp
|
| Almacenamiento | DuckDB | Data warehouse analítico embebido (un solo archivo) |
| Transform | dbt | Modelos staging → |
Si te sirvió, deja un ❤️ o cuéntame en los comentarios qué le agregarías al pipeline.
Jhony Vargas Luque, estudiante del curso de Inteligencia de Negocios.



Top comments (0)