---
title: "1.3.4 Proveedores de datos profesionales"
description: "Databento, Nasdaq Data Link, LSEG, Bloomberg e ICE: qué venden, cómo cobran y cuánto ocupan los datos tick y de libro, estimado con una sesión del curso."
url: "https://pythonparatrading.com/curso-python-trading/nivel-1/proveedores-de-datos-profesionales/"
lang: "es"
image: "https://pythonparatrading.com/og/curso-python-trading/nivel-1/proveedores-de-datos-profesionales.png"
---

# 1.3.4 · Proveedores de datos profesionales

> Por encima de las APIs retail están los proveedores que venden datos directos de las bolsas, el libro orden a orden y décadas de referencia. Esta lección los ordena, explica cómo cobran y estima con una sesión simulada de NOVA cuánto ocupa un año de ticks antes de pedir un presupuesto.

- Curso: [Nivel 1: Datos financieros, mercados y análisis](https://pythonparatrading.com/curso-python-trading/nivel-1/)
- Módulo: 1.3 · Fuentes de datos de mercado
- Duración: 50 min
- Requisitos: [1.1.3 · Libro de órdenes: bid, ask, spread y profundidad](https://pythonparatrading.com/curso-python-trading/nivel-1/libro-de-ordenes-bid-ask-y-profundidad/), [1.3.1 · Tipos de datos de mercado: EOD, barras, ticks, libro y referencia](https://pythonparatrading.com/curso-python-trading/nivel-1/tipos-de-datos-de-mercado/), [1.3.3 · APIs de datos retail y prosumer](https://pythonparatrading.com/curso-python-trading/nivel-1/apis-de-datos-retail-y-prosumer/)

## Al terminar esta lección

- Situar a Databento, Nasdaq Data Link, LSEG, Bloomberg e ICE por lo que venden y a quién.
- Explicar el modelo de cobro por uso (por gigabyte) frente a la suscripción, y por qué un histórico tick se presupuesta antes de pedirlo.
- Estimar con pandas el número de mensajes y el tamaño de un año de datos por esquema (operaciones, top of book, profundidad, orden a orden) a partir de una sesión.
- Reconocer los esquemas de datos de mercado de un proveedor profesional (MBO, MBP-10, MBP-1, trades, OHLCV) y su coste relativo.

## 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.

```mermaid
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.

| Proveedor | Qué vende | Para quién | Precio |
|---|---|---|---|
| Databento | Feeds de bolsa normalizados: futuros de CME, acciones de EE. UU., opciones OPRA; histórico y tiempo real | Desde particulares hasta fondos | Publicado: uso por GB y planes |
| Nasdaq Data Link | Plataforma de conjuntos de datos (antes Quandl): gratuitos y de pago, fundamentales, alternativos | Analistas, research | Por conjunto |
| LSEG (antes Refinitiv) | Workspace (terminal), datos de referencia, tiempo real, histórico | Bancos, gestoras | Negociado |
| Bloomberg | Terminal, feed B-PIPE, Data License | Bancos, gestoras, mesas | Negociado |
| ICE | Datos de renta fija, feed consolidado, índices | Institucional | Negociado |

## 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 principales[^1]:

- **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.

*Fig. — Inicio de la historia de tres conjuntos de datos de Databento, según su documentación (consultada el 21/10/2026).* Línea de tiempo de 2009 a 2027. CME Globex (GLBX.MDP3) empieza el 6 de junio de 2010: hasta mayo de 2017 con el protocolo anterior FIX/FAST y desde entonces con MDP 3.0, tramo destacado. OPRA empieza el 1 de abril de 2013 y Nasdaq TotalView-ITCH el 1 de mayo de 2018.

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/2026[^2]:

- **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):

```python skip title="databento_coste.py"
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()`[^3]. 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)[^4].
Los principales, con el tamaño de cada registro en su formato binario DBN (versión 3)[^5]:

| Esquema | Qué contiene | Nivel | Bytes por registro |
|---|---|---|---|
| `mbo` | Cada alta, cancelación, modificación y ejecución de cada orden | L3 | 56 |
| `mbp-10` | Los 10 mejores niveles de cada lado, en cada cambio | L2 | 368 |
| `mbp-1` / `tbbo` | El mejor bid y ask, en cada cambio (o en cada operación) | L1 | 80 |
| `trades` | Cada operación | L1 | 48 |
| `ohlcv-1s`, `-1m`, `-1h`, `-1d` | Barras | L0 | 56 |
| `definition` | Definición de cada instrumento | Referencia | 520 |

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:

```python
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")
```
```output
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.

```python
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)
```
```output
                      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:

```python
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()
```
```output
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:

```python
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})
```
```output
          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:

```python
sesiones, valores = 252, 100
estim["gb_ano"] = estim["mb_dia"] * sesiones * valores / 1e3
estim[["mb_dia", "gb_ano"]].round(1).sort_values("gb_ano")
```
```output
          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.

<aside class="callout" data-kind="aviso">

Como el histórico se cobra por tamaño, elegir `mbp-10` cuando el sistema solo usa el mejor precio multiplica la factura
sin mejorar nada. Para un estudio de ejecución bastan casi siempre `trades` y `mbp-1`; `mbo` hace falta para reconstruir
el libro o detectar icebergs (lección 1.1.3). Antes de una descarga grande, `get_cost` con un día de muestra.

</aside>

## 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
Link**[^6]. 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`).

```python skip title="nasdaq_data_link.py"
# 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-data`[^7].
- **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 lotes[^8].
- **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 Indices**[^9].

```mermaid
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?

**Solución.**

```python
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%})")
```
```output
10785 operaciones en los extremos de 42646
mbo: 393,475 -> 492,983 mensajes (+25%)
```

Las dos medias horas de los extremos, 60 de los 390 minutos de la sesión (el 15 %), concentran una cuarta parte de las
operaciones con libro: 10.785 de 42.646 (el volumen en U de la lección 1.1.2). Doblar su proporción de mensajes sube el
total un 25 %, hasta unos 493.000 mensajes al día. La lección: una estimación hecha con una ventana
tranquila infravalora el volumen, y conviene muestrear varios tramos del día antes de presupuestar.

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`.

**Solución.**

```python
por_valor_ano = estim["mb_dia"] * sesiones / 1e3      # GB
(1000 / por_valor_ano[["mbp-1", "trades"]]).round(0)
```
```output
mbp-1      275.0
trades    1623.0
Name: mb_dia, dtype: float64
```

Un terabyte da para un año de top of book de unos 275 valores como NOVA, o para un año de operaciones de más de 1.600.
Es una forma útil de decidir el universo de un estudio intradía: muchas veces, menos valores con más detalle enseñan
más que muchos con barras.

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?

**Solución.**

Que el periodo 2010-2017 no es igual que el resto: antes de mayo de 2017 los datos salen del protocolo FIX/FAST anterior
y, hasta el 21 de mayo de 2017, no tienen marcas de captura, así que un estudio de latencias o de microestructura fina
no es comparable a ambos lados de esa fecha. Además: qué esquema necesita de verdad (para un sistema con barras de
minuto basta `ohlcv-1m`, que ocupa muy poco), qué contratos (solo los que va a operar, con sus vencimientos, lección
1.2.3), el coste con `get_cost` antes de descargar, y la licencia de uso de los datos de CME (lección 1.3.7).

[^1]: Databento: [GLBX.MDP3](https://databento.com/docs/datasets/glbx-mdp3), [XNAS.ITCH](https://databento.com/datasets/XNAS.ITCH) y [OPRA.PILLAR](https://databento.com/datasets/OPRA.PILLAR), consultadas el 21/10/2026.
[^2]: [Databento: Pricing](https://databento.com/pricing), consultada el 21/10/2026.
[^3]: Databento: [timeseries.get_range](https://databento.com/docs/api-historical/timeseries/timeseries-get-range), [metadata.get_cost](https://databento.com/docs/api-historical/metadata/metadata-get-cost) y [metadata.get_billable_size](https://databento.com/docs/api-historical/metadata/metadata-get-billable-size).
[^4]: [Databento: What's a schema?](https://databento.com/docs/schemas/whats-a-schema)
[^5]: Tamaños comprobados en el código fuente del formato DBN ([record.rs](https://github.com/databento/dbn/blob/main/rust/dbn/src/record.rs), DBN versión 3) y cabecera de 16 bytes en [Databento Binary Encoding](https://databento.com/docs/conventions/databento-binary-encoding).
[^6]: [Nasdaq Data Link](https://data.nasdaq.com/) y el README del cliente [quandl-python](https://github.com/quandl/quandl-python).
[^7]: [Thomson Reuters: anuncio del nombre Refinitiv](https://www.thomsonreuters.com/en/press-releases/2018/july/thomson-reuters-financial-and-risk-business-announces-new-company-name-refinitiv) (27/07/2018), [LSEG: historia](https://www.lseg.com/en/about-us/history), [retirada de Eikon](https://www.lseg.com/en/data-analytics/products/eikon-trading-software) y [LSEG Data Library for Python](https://developers.lseg.com/en/api-catalog/lseg-data-platform/lseg-data-library-for-python).
[^8]: Bloomberg Professional: [Terminal](https://professional.bloomberg.com/products/bloomberg-terminal/), [API Library](https://professional.bloomberg.com/support/api-library/), [B-PIPE](https://professional.bloomberg.com/products/data/enterprise-catalog/real-time-data-feed/) y [Data License](https://professional.bloomberg.com/products/data/data-license/).
[^9]: ICE: [Fixed Income & Data Services](https://www.ice.com/fixed-income-data-services), [ICE Consolidated Feed](https://www.ice.com/fixed-income-data-services/access-and-delivery/connectivity-and-feeds/consolidated-feed) e [Index Solutions](https://www.ice.com/fixed-income-data-services/index-solutions).

## Autoevaluación

1. Databento cobra el histórico por uso en dólares por gigabyte. ¿Sobre qué tamaño, según su página de precios?

   - A. Sobre el tamaño del archivo comprimido que descargas
   - B. Sobre el tamaño sin comprimir en su codificación binaria
   - C. Sobre el número de símbolos
   - D. Sobre el número de peticiones

   *Respuesta B: Sobre el tamaño sin comprimir en su codificación binaria.* Su FAQ de precios dice que todos los datos se cobran por su tamaño sin comprimir en codificación binaria. Por eso el tamaño de cada registro de cada esquema determina el coste.

2. ¿Qué esquema ocupa más por día en la estimación con la sesión de NOVA?

   - A. trades
   - B. mbp-1
   - C. mbp-10
   - D. ohlcv-1m

   *Respuesta C: mbp-10.* mbp-10 lleva los diez mejores niveles de cada lado en cada mensaje: 368 bytes por registro. Con los ~393.000 mensajes estimados de NOVA son unos 145 MB al día, frente a 22 MB del orden a orden (56 bytes) y 2,4 MB de las operaciones.

3. El conjunto de CME de Databento empieza en junio de 2010. ¿Qué matiz da su documentación?

   - A. Ninguno: todo es MDP 3.0 desde 2010
   - B. Antes de mayo de 2017 los datos salen del protocolo anterior (FIX/FAST) y, hasta el 21 de mayo de 2017, sin marcas de captura
   - C. Antes de 2017 solo hay barras diarias
   - D. Antes de 2017 no hay opciones

   *Respuesta B: Antes de mayo de 2017 los datos salen del protocolo anterior (FIX/FAST) y, hasta el 21 de mayo de 2017, sin marcas de captura.* La cobertura empieza en 2010, pero la granularidad y las marcas no son iguales en toda la serie. Un estudio de microestructura que cruce 2017 tiene que saberlo.

4. ¿Qué es Nasdaq Data Link?

   - A. El feed de libro de Nasdaq
   - B. La plataforma de datos que antes se llamaba Quandl, con conjuntos gratuitos y de pago como los fundamentales de Sharadar
   - C. Una bolsa alternativa
   - D. La API de Bloomberg

   *Respuesta B: La plataforma de datos que antes se llamaba Quandl, con conjuntos gratuitos y de pago como los fundamentales de Sharadar.* quandl.com redirige a data.nasdaq.com; el cliente de Python es `nasdaq-data-link`. Los fundamentales Core US de Sharadar (SF1) son un conjunto de pago de esa plataforma.

5. Quieres usar `blpapi` con un Terminal de Bloomberg. ¿Qué tienes que saber?

   - A. Que se instala con `pip install blpapi` desde PyPI
   - B. Que se instala desde el índice propio de Bloomberg, y que la API de escritorio es la que usa el Terminal; los productos de servidor (Server API, B-PIPE) son otros
   - C. Que es gratuita para todo el mundo
   - D. Que solo funciona en Linux

   *Respuesta B: Que se instala desde el índice propio de Bloomberg, y que la API de escritorio es la que usa el Terminal; los productos de servidor (Server API, B-PIPE) son otros.* Bloomberg documenta la instalación con `pip --index-url` apuntando a su repositorio. El Terminal, B-PIPE y Data License son productos distintos, con contratos distintos.

## Ideas clave

- El escalón profesional vende datos directos de bolsa (libro completo, orden a orden), referencia y décadas de historia, con licencias de bolsa y contratos.
- Databento cobra el histórico por uso (dólares por gigabyte sin comprimir) y el tiempo real por suscripción; su API permite pedir el coste y el tamaño antes de descargar.
- El tamaño lo decide el esquema: un registro de operaciones ocupa 48 bytes; uno de top of book, 80; uno de diez niveles, 368. Con la sesión de NOVA, un año de 100 valores así va de medio gigabyte (barras de minuto) a más de 3,6 TB (diez niveles).
- Nasdaq Data Link (antes Quandl), LSEG (antes Refinitiv), Bloomberg e ICE cubren referencia, fundamentales, índices y terminales; sus precios no son públicos y se negocian.
- Antes de pagar un histórico tick, se estima su volumen con una muestra y se pide el presupuesto al proveedor; descargar «todo» rara vez hace falta.

## Recursos

### Research

- [Liquidez Order Book - Trading Liquidez Agregada](https://pythonparatrading.com/limit-order-book-y-liquidez-de-mercado/) · Research-0008 · 11 min

### Documentación

- [Databento: precios (uso por GB y planes)](https://databento.com/pricing) · databento.com
- [Databento: What's a schema? (esquemas de datos)](https://databento.com/docs/schemas/whats-a-schema) · databento.com
- [Databento: CME Globex MDP 3.0 (GLBX.MDP3), especificaciones](https://databento.com/docs/datasets/glbx-mdp3) · databento.com
- [Databento DBN: tamaños de los registros (record.rs)](https://github.com/databento/dbn/blob/main/rust/dbn/src/record.rs) · github.com
- [LSEG Data Library for Python](https://developers.lseg.com/en/api-catalog/lseg-data-platform/lseg-data-library-for-python) · developers.lseg.com

### Datos

- [Datos del nivel 1: mensajes L3 de NOVA (Parquet)](https://pythonparatrading.com/curso/datos/nivel-1/nova_libro_l3.parquet) · Descarga · nova_libro_l3.parquet

Lección anterior: [1.3.3 · APIs de datos retail y prosumer](https://pythonparatrading.com/curso-python-trading/nivel-1/apis-de-datos-retail-y-prosumer/)

Lección siguiente: [1.3.5 · Datos de cripto y on-chain](https://pythonparatrading.com/curso-python-trading/nivel-1/datos-de-cripto-y-on-chain/)
