Proveedores de datos profesionales.

Qué cambia en el escalón profesional

Las APIs de la lección 1.3.3 venden barras, operaciones y, en los planes altos, la mejor cotización. Un proveedor profesional vende otra cosa: los feeds directos de cada bolsa, con el libro completo orden a orden (L3, lección 1.1.3), las marcas de tiempo del propio centro, datos de referencia (definiciones de instrumentos, eventos corporativos, índices) y décadas de historia. Y lo vende con otras condiciones: licencias de cada bolsa, contratos anuales y precios que muchas veces no se publican.

flowchart TB
  B[Bolsas y centros] --> F[Feeds directos]
  B --> S[Cinta consolidada]
  F --> P[Proveedor]
  S --> P
  P --> N[Datos normalizados]
  N --> T[Tu sistema]

El trabajo del proveedor es capturar cada feed (cada bolsa tiene su protocolo), normalizarlo a un formato común, guardarlo con marcas de tiempo fiables y servirlo por API o en archivos. Lo que se paga es eso: no el dato en sí, que sale de la bolsa, sino la captura, la normalización, la historia y la licencia.

Databento: feeds de bolsa con precio publicado

Databento es el caso más accesible del escalón, porque publica precios y documentación completa. Sus conjuntos de datos llevan el nombre del feed de origen; tres de los principales11Nota 1 · Databento: GLBX.MDP3, XNAS.ITCH y OPRA.PILLAR, consultadas el 21/10/2026.:

• GLBX.MDP3: CME Globex (futuros y opciones sobre futuros de CME, CBOT, NYMEX y COMEX). La cobertura empieza el 6 de junio de 2010, con un matiz que da su propia documentación: CME introdujo el protocolo MDP 3.0 en mayo de 2017; antes, los datos salen del protocolo anterior (FIX/FAST), y hasta el 21 de mayo de 2017 no tienen marcas de captura.
• XNAS.ITCH: Nasdaq TotalView-ITCH, el libro completo de Nasdaq, desde el 1 de mayo de 2018.
• OPRA.PILLAR: opciones sobre acciones de EE. UU. (operaciones y mejor precio consolidado de todas las bolsas de opciones), desde el 1 de abril de 2013.

Para acciones de EE. UU., su página principal habla de 15 bolsas y 30 ATS, con feeds propios de L3 y las cintas consolidadas. Y el modelo de precio separa histórico y tiempo real. Según su página de precios, a fecha de 21/10/202622Nota 2 · Databento: Pricing, consultada el 21/10/2026.:

• Histórico por uso: se paga por gigabyte, y el tamaño que cuenta es el de los datos sin comprimir en su codificación binaria. También se puede usar con cualquier suscripción.
• Tiempo real por plan: Standard, 199 USD al mes con facturación mensual; Plus y Unlimited, con contrato anual y 1.750 y 4.500 USD al mes en licencias. La página muestra estos planes con la cobertura de CME; los importes pueden variar con el conjunto de datos elegido.
• Un crédito inicial de 125 USD al registrarse, que caduca a los seis meses.

Que el histórico se cobre por tamaño cambia la forma de trabajar: antes de descargar se calcula cuánto ocupa lo que se pide. Su cliente de Python tiene métodos para eso (necesita red y clave):

import os

import databento as db             # uv add databento

client = db.Historical(os.environ["DATABENTO_API_KEY"])
peticion = dict(dataset="GLBX.MDP3", symbols=["ESZ5"],
                schema="trades", start="2025-10-01", end="2025-10-02")

print(client.metadata.get_billable_size(**peticion), "bytes")
print(client.metadata.get_cost(**peticion), "USD")

datos = client.timeseries.get_range(**peticion)   # cobra
df = datos.to_df()

get_billable_size devuelve los bytes facturables sin comprimir y get_cost, el coste en dólares de esa petición; timeseries.get_range descarga y devuelve un objeto que se convierte a DataFrame con to_df()33Nota 3 · Databento: timeseries.get_range, metadata.get_cost y metadata.get_billable_size.. La buena práctica es preguntar primero y descargar después.

Esquemas: lo que decide el tamaño

Un mismo mercado se puede pedir con distinto detalle. Databento llama esquemas a esos formatos (más de quince) y los agrupa por nivel: L0 (barras, estadísticas), L1 (mejor precio), L2 (profundidad por niveles) y L3 (orden a orden)44Nota 4 · Databento: What's a schema?. Los principales, con el tamaño de cada registro en su formato binario DBN (versión 3)55Nota 5 · Tamaños comprobados en el código fuente del formato DBN (record.rs, DBN versión 3) y cabecera de 16 bytes en Databento Binary Encoding.:

Todos los registros empiezan con la misma cabecera de 16 bytes (tipo, instrumento, marca de tiempo del evento). El orden a orden (mbo) es el más detallado, pero cada mensaje es pequeño; mbp-10 repite los diez niveles en cada cambio y por eso es el más pesado por registro. Un registro de operaciones de NOVA se puede escribir igual, con un tipo compuesto de numpy, para ver de dónde salen esos números:

import numpy as np
import pandas as pd

registro_op = np.dtype([
    ("ts", "<u8"),        # nanosegundos desde 1970
    ("precio", "<i8"),    # precio en entero (escala fija)
    ("tamano", "<u4"),
    ("agresor", "u1"), ("centro", "u1"), ("condicion", "u1"),
])
print(registro_op.itemsize, "bytes por operación")

op = pd.read_parquet("nova_operaciones.parquet")
csv = len(op.to_csv(index=False).encode())
print(f"CSV: {csv / len(op):.1f} bytes por operación")

23 bytes por operación
CSV: 65.9 bytes por operación

23 bytes por operación en binario propio, frente a casi 66 en CSV. El Parquet del curso ocupa todavía menos, porque comprime: columnas con pocos valores distintos (centro, condición) y precios en una rejilla de céntimos se comprimen muy bien.

from pathlib import Path

filas = {}
for nombre in ["nova_operaciones", "nova_cotizaciones",
               "nova_libro_l2", "nova_libro_l3"]:
    df = pd.read_parquet(f"{nombre}.parquet")
    filas[nombre] = {
        "filas": len(df),
        "csv": len(df.to_csv(index=False).encode()) / len(df),
        "parquet": Path(f"{nombre}.parquet").stat().st_size / len(df),
    }
pd.DataFrame(filas).T.round(1)

                      filas   csv  parquet
nova_operaciones    50946.0  65.9      4.2
nova_cotizaciones  129247.0  55.4      6.5
nova_libro_l2       44126.0  45.4      3.6
nova_libro_l3        7241.0  64.0      6.2

Entre 3,6 y 6,5 bytes por fila en Parquet: de 8 a 16 veces menos que en CSV. Los datos sintéticos se comprimen mejor que los reales (precios más regulares), así que en datos de mercado la ganancia es menor, pero sigue siendo grande. Por eso el tamaño facturable (sin comprimir) y el que ocupa el disco son cosas distintas: un proveedor que cobra por tamaño sin comprimir no cobra menos porque los datos se compriman bien, y uno que entrega archivos comprimidos los entrega mucho más pequeños de lo que se paga. El registro de Databento ocupa 48 porque lleva más campos (la cabecera común, la marca de recepción, el número de secuencia, banderas). Los precios van como enteros con escala fija (por ejemplo, en milmillonésimas de dólar) y no como flotantes: así no hay errores de redondeo (lección 0.3.1) y la comparación de precios es exacta.

Cuánto ocupa un año de ticks

Con los tamaños por registro, el volumen de una petición se estima contando mensajes. La sesión de NOVA tiene operaciones de todo el día, cotizaciones de todo el día y mensajes L3 de solo cinco minutos (de 10:00 a 10:05 en Nueva York). Para estimar los mensajes L3 del día entero se usa la proporción entre mensajes y ejecuciones en esa ventana:

l3 = pd.read_parquet("nova_libro_l3.parquet")
foto = (l3["ts"] == l3["ts"].iloc[0]).sum()     # foto inicial
mensajes = len(l3) - foto
ejecuciones = (l3["evento"] == "ejecucion").sum()
por_ejecucion = mensajes / ejecuciones
print(mensajes, "mensajes,", ejecuciones, "ejecuciones")
print(f"{por_ejecucion:.2f} mensajes por ejecución")
l3["evento"].iloc[foto:].value_counts()

6883 mensajes, 746 ejecuciones
9.23 mensajes por ejecución
evento
alta            3085
cancelacion     2842
ejecucion        746
modificacion     210
Name: count, dtype: int64

Por cada ejecución hay 9,23 mensajes en total: sobre todo altas (3.085) y cancelaciones (2.842) de órdenes que nunca llegan a ejecutarse. Es lo normal en un libro con creadores de mercado, que mueven sus órdenes continuamente (lección 1.1.3). Con esa proporción y las operaciones del día en los centros con libro:

cot = pd.read_parquet("nova_cotizaciones.parquet")
con_libro = op["centro"].isin(["PRINCIPAL", "MTF_A", "MTF_B"]).sum()
mbo_dia = con_libro * por_ejecucion

estim = pd.DataFrame({
    "mensajes": {
        "mbo": mbo_dia,
        "mbp-10": mbo_dia,                    # cota superior
        "mbp-1": len(cot) + len(op),
        "trades": len(op),
        "ohlcv-1s": op["ts"].dt.floor("s").nunique(),
        "ohlcv-1m": 390,
    },
    "bytes": {"mbo": 56, "mbp-10": 368, "mbp-1": 80, "trades": 48,
              "ohlcv-1s": 56, "ohlcv-1m": 56},
})
estim["mb_dia"] = estim["mensajes"] * estim["bytes"] / 1e6
estim.round({"mensajes": 0, "mb_dia": 2})

          mensajes  bytes  mb_dia
mbo       393475.0     56   22.03
mbp-10    393475.0    368  144.80
mbp-1     180193.0     80   14.42
trades     50946.0     48    2.45
ohlcv-1s   17908.0     56    1.00
ohlcv-1m     390.0     56    0.02

Las hipótesis, para que quede claro qué se ha estimado y qué no:

• mbo: los mensajes L3 de la ventana, escalados por las 42.646 operaciones con libro del día. La ventana es de media mañana; en la apertura y el cierre hay más actividad, así que puede quedarse corta.
• mbp-10: como cota superior, un registro por mensaje L3 (todo cambio dentro de los diez primeros niveles genera uno).
• mbp-1: un registro por cambio del mejor precio (nova_cotizaciones) más uno por operación.
• ohlcv-1s: una barra por segundo con alguna operación (17.908 de los 23.400 segundos de la sesión); ohlcv-1m, las 390 barras de minuto de la sesión regular.

Con esto, escalar es multiplicar. Un año (252 sesiones) de 100 valores como NOVA:

sesiones, valores = 252, 100
estim["gb_ano"] = estim["mb_dia"] * sesiones * valores / 1e3
estim[["mb_dia", "gb_ano"]].round(1).sort_values("gb_ano")

          mb_dia  gb_ano
ohlcv-1m     0.0     0.6
ohlcv-1s     1.0    25.3
trades       2.4    61.6
mbp-1       14.4   363.3
mbo         22.0   555.3
mbp-10     144.8  3648.9

La figura de la cabecera lo dibuja en escala logarítmica. Del medio gigabyte de las barras de minuto a más de 3,6 TB de los diez niveles: cuatro órdenes de magnitud por elegir el esquema. Son cifras de una acción ficticia con una actividad concreta; una acción real muy líquida puede tener muchos más mensajes, y una poco líquida, muchos menos. El método es lo que vale: contar mensajes en una muestra, multiplicar por el tamaño del registro y por el periodo, y comparar con lo que de verdad necesita el sistema.

Nasdaq Data Link, antes Quandl

Quandl fue durante años la plataforma de referencia de datos para research en Python; hoy quandl.com redirige a data.nasdaq.com y el propio repositorio de su cliente explica que la plataforma se ha transformado en Nasdaq Data Link66Nota 6 · Nasdaq Data Link y el README del cliente quandl-python.. Funciona como un catálogo: cada proveedor publica sus conjuntos (tablas o series) y se pagan por separado. Un ejemplo de pago muy usado en research de acciones son los fundamentales Core US de Sharadar (tabla SHARADAR/SF1).

# la clave se lee sola de la variable NASDAQ_DATA_LINK_API_KEY
import nasdaqdatalink                # uv add nasdaq-data-link

fund = nasdaqdatalink.get_table("SHARADAR/SF1", ticker="AAPL")

Lo importante al evaluar un conjunto de Data Link no es la plataforma sino el proveedor de ese conjunto: qué cubre, desde cuándo, si incluye empresas deslistadas y si los fundamentales son point-in-time (lecciones 1.3.8 y 1.5.1).

LSEG, Bloomberg e ICE: la cultura de la industria

Estos tres no se contratan para un sistema personal, pero aparecen en cualquier conversación del sector y conviene saber qué es cada cosa.

• LSEG. La división de datos de Thomson Reuters pasó a llamarse Refinitiv en julio de 2018 y LSEG (London Stock Exchange Group) completó su compra en enero de 2021. El terminal Eikon se retiró el 30 de junio de 2025 y su sustituto es LSEG Workspace. La librería de Python actual es lseg-data, versión 2 de la antigua refinitiv-data77Nota 7 · Thomson Reuters: anuncio del nombre Refinitiv (27/07/2018), LSEG: historia, retirada de Eikon y LSEG Data Library for Python..
• Bloomberg. El Terminal es el producto de escritorio de datos, noticias y análisis. Para programas está la API (BLPAPI), cuyo paquete de Python se instala desde el repositorio de Bloomberg, no desde PyPI; el Terminal usa la API de escritorio y los productos de servidor son otros: B-PIPE, el feed de datos de mercado en tiempo real, y Data License, los datos de referencia, precios e históricos por lotes88Nota 8 · Bloomberg Professional: Terminal, API Library, B-PIPE y Data License..
• ICE (Intercontinental Exchange) tiene un negocio de datos propio: precios y referencia de renta fija, el ICE Consolidated Feed (contenido de más de 600 fuentes) y los índices de ICE Data Indices99Nota 9 · ICE: Fixed Income & Data Services, ICE Consolidated Feed e Index Solutions..

flowchart TB
  Q{¿Qué necesitas?} -- ticks y libro --> D[Databento]
  Q -- fundamentales --> N[Nasdaq Data Link]
  Q -- todo y noticias --> T[Terminal]
  Q -- renta fija --> I[ICE o LSEG]

El diagrama es una simplificación: los grandes cubren casi todo, y la elección real depende del contrato que ya tenga la empresa. Para un particular o un equipo pequeño, lo habitual es combinar un proveedor de feeds con precio publicado para el mercado que se opera y una fuente de fundamentales.

Ejercicios

1. Repite la estimación de mbo suponiendo que la apertura y el cierre tienen el doble de mensajes por ejecución que la ventana de media mañana: aplica 2 × por_ejecucion a las operaciones de la primera y la última media hora. ¿Cuánto sube el volumen diario?

hora = op["ts"].dt.tz_convert("America/New_York").dt.strftime("%H:%M")
extremo = (hora < "10:00") | (hora >= "15:30")
libro = op["centro"].isin(["PRINCIPAL", "MTF_A", "MTF_B"])
n_ext = (libro & extremo).sum()
n_resto = (libro & ~extremo).sum()
mbo2 = n_ext * 2 * por_ejecucion + n_resto * por_ejecucion
print(n_ext, "operaciones en los extremos de", libro.sum())
print(f"mbo: {mbo_dia:,.0f} -> {mbo2:,.0f} mensajes "
      f"(+{mbo2 / mbo_dia - 1:.0%})")

10785 operaciones en los extremos de 42646
mbo: 393,475 -> 492,983 mensajes (+25%)

2. Con la tabla estim, calcula para cuántos valores cabe un año de mbp-1 en 1 TB, y para cuántos de trades.

por_valor_ano = estim["mb_dia"] * sesiones / 1e3      # GB
(1000 / por_valor_ano[["mbp-1", "trades"]]).round(0)

mbp-1      275.0
trades    1623.0
Name: mb_dia, dtype: float64

3. Un amigo quiere «descargar todo el libro de CME desde 2010» para investigar futuros. Con lo que dice la documentación de Databento sobre ese conjunto, ¿qué le recomendarías comprobar antes?