Tipos de órdenes.

Precio o ejecución: el dilema de toda orden

Una orden le dice al bróker qué comprar o vender, cuánto y en qué condiciones. Todas las variantes que existen salen de una decisión básica:

• Orden de mercado. Ejecutar ya, al precio que haya. Garantiza la ejecución (si hay contrapartida) y no garantiza el precio.
• Orden limitada. Ejecutar solo a un precio igual o mejor que el límite. Garantiza el precio y no garantiza la ejecución.

Una compra limitada por encima del mejor ask es marketable: se ejecuta al momento, como una de mercado, pero con un tope. Una compra limitada por debajo del mejor bid se queda en el libro, al final de la cola de su precio, y espera (lección 1.1.3). El resto de tipos añade a estas dos una condición (un precio de disparo, una hora, un tamaño mínimo) o una relación con otras órdenes.

La figura sitúa cada tipo respecto al libro. Las limitadas esperan del lado «bueno» del precio: compras por debajo, ventas por encima. Los stops esperan del lado «malo»: un stop de venta está por debajo del bid y se dispara si el precio cae hasta él; un stop de compra, por encima del ask. Las órdenes de mercado no esperan: cruzan la horquilla.

Un motor de cruce de veinte líneas

La mejor forma de entender una orden es ejecutarla. Este motor recorre los niveles de un lado del libro en orden de prioridad y devuelve las ejecuciones. Se usa la foto L2 de NOVA de las 15:00 de Nueva York de la lección 1.1.3, con el mejor ask a 52,75.

import pandas as pd

l2 = pd.read_parquet("nova_libro_l2.parquet")
foto = l2[l2["ts"] == "2025-06-02 19:00:00+00:00"]
asks = foto[foto["lado"] == "ask"].sort_values("precio")
bids = foto[foto["lado"] == "bid"].sort_values("precio",
                                                ascending=False)
lado_venta = list(zip(asks["precio"], asks["tamano"]))
lado_compra = list(zip(bids["precio"], bids["tamano"]))
medio = (asks["precio"].iloc[0] + bids["precio"].iloc[0]) / 2
lado_venta[:4]

[(52.75, 1870), (52.76, 9900), (52.77, 13280), (52.78, 17322)]

def recorre(niveles, cantidad, limite=None, compra=True):
    """Ejecuta contra `niveles` [(precio, tamaño)] hasta `cantidad`.
    Con `limite`, no pasa de ese precio.
    Devuelve (ejecuciones, resto)."""
    ejecuciones, resto = [], cantidad
    for precio, tam in niveles:
        if limite is not None and (precio > limite if compra
                                   else precio < limite):
            break
        q = min(resto, tam)
        ejecuciones.append((precio, q))
        resto -= q
        if resto == 0:
            break
    return ejecuciones, resto

def resumen(ejecuciones, medio):
    q = sum(c for _, c in ejecuciones)
    pm = sum(p * c for p, c in ejecuciones) / q
    return {"acciones": q, "niveles": len(ejecuciones),
            "precio_medio": round(float(pm), 4),
            "sobre_medio_cent": round(float(100 * abs(pm - medio)), 2)}

for n in (2_000, 30_000):
    ejec, resto = recorre(lado_venta, n)
    print(f"compra a mercado de {n}:", resumen(ejec, medio))

compra a mercado de 2000: {'acciones': 2000, 'niveles': 2, 'precio_medio': 52.7507, 'sobre_medio_cent': 0.56}
compra a mercado de 30000: {'acciones': 30000, 'niveles': 4, 'precio_medio': 52.7671, 'sobre_medio_cent': 2.21}

Una compra a mercado de 2.000 acciones se llena con el primer nivel entero (1.870 acciones a 52,75) y 130 del segundo, a 52,76: precio medio 52,7507, 0,56 céntimos por encima del medio. Una de 30.000 recorre cuatro niveles y paga de media 52,7671: 2,21 céntimos sobre el medio, casi cuatro veces más por acción. Es el impacto de la orden, el coste que crece con el tamaño (la lección 1.1.5 lo convierte en una curva):

Validez: DAY, GTC, IOC y FOK

Además del precio, una orden lleva una validez (time in force), que dice cuánto tiempo vive:

Con el motor anterior, IOC y FOK son dos líneas:

def limitada(niveles, cantidad, limite, validez, compra=True):
    ejec, resto = recorre(niveles, cantidad, limite, compra)
    if validez == "FOK" and resto > 0:
        return [], cantidad, "cancelada: no hay suficiente"
    if validez == "IOC":
        estado = "ejecutada" if resto == 0 else f"cancela {resto}"
        return ejec, resto, estado
    return ejec, resto, f"{resto} quedan en el libro"

for validez in ("IOC", "FOK", "DAY"):
    ejec, resto, estado = limitada(lado_venta, 15_000, 52.76, validez)
    print(validez, "ejecuta", sum(q for _, q in ejec), "·", estado)

IOC ejecuta 11770 · cancela 3230
FOK ejecuta 0 · cancelada: no hay suficiente
DAY ejecuta 11770 · 3230 quedan en el libro

A 52,76 o mejor solo hay 11.770 acciones. La IOC se las lleva y cancela las 3.230 que faltan; la FOK no ejecuta nada; la DAY ejecuta lo mismo que la IOC y deja una compra de 3.230 acciones a 52,76 en el libro, que pasa a ser el nuevo mejor bid: ha cruzado la horquilla y ahora la define.

Las órdenes a la apertura y al cierre se cruzan en las subastas (lección 1.1.2). En la NYSE hay variantes a mercado (MOO, MOC) y limitadas (LOO, LOC); las MOC y LOC se pueden enviar, modificar o cancelar hasta las 15:50, y después solo se aceptan las que reducen el desequilibrio publicado11Nota 1 · NYSE, folleto «NYSE opening and closing auctions» (consultado el 21 de octubre de 2026)..

Stop, stop-limit y trailing en un hueco

Un stop es una orden dormida con un precio de disparo. Un stop de venta a 62,50 no hace nada mientras el precio esté por encima; cuando se negocia a 62,50 o menos, se convierte en una orden de mercado. Un stop-limit se convierte en una limitada: «si cae a 62,50, vende, pero no por debajo de 62,30». Un trailing stop mueve el disparo detrás del precio: se queda, por ejemplo, un 2,5 % por debajo del máximo alcanzado desde la entrada, y solo sube.

La diferencia entre los tres importa en los huecos: cuando el precio salta de un nivel a otro sin pasar por los intermedios, típicamente de un cierre a la apertura siguiente tras una noticia. NOVA presentó resultados tras el cierre del jueves 24 de octubre de 2024 y el viernes abrió un 5,1 % más abajo:

diario = pd.read_csv("nova_diario_sin_ajustar.csv",
                     parse_dates=["fecha"])
diario["hueco_pct"] = 100 * (diario["apertura"]
                             / diario["cierre"].shift() - 1)
tramo = diario[diario["fecha"].between("2024-10-21", "2024-10-28")]
tramo.set_index("fecha").round(2)

            apertura  maximo  minimo  cierre   volumen  hueco_pct
fecha
2024-10-21     63.27   64.32   62.90   64.30  13820466       0.02
2024-10-22     64.26   64.47   63.74   64.07   9126443      -0.06
2024-10-23     63.93   64.67   63.76   64.19   8728289      -0.22
2024-10-24     64.11   64.60   63.21   63.40   9874612      -0.12
2024-10-25     60.14   60.87   59.51   59.59  51399629      -5.14
2024-10-28     59.25   59.33   57.11   58.02  18793763      -0.57

Un sistema compra al cierre del 21 de octubre, a 64,30, y protege la posición de tres formas: un stop a 62,50, un stop-limit 62,50/62,30 válido para el día y un trailing stop del 2,5 %. Las barras de 5 minutos permiten simular cuándo se dispara cada uno. La regla de ejecución de un stop sobre barras es la honrada: si la barra abre por debajo del stop, la venta sale a la apertura; si abre por encima y su mínimo lo toca, sale al stop (y aun así es optimista: en la realidad, al primer precio negociado después).

barras = pd.read_parquet("nova_barras_5min.parquet")
barras = (barras[barras["ts"] > "2024-10-21 20:00"]
          .reset_index(drop=True))
entrada = 64.30

def stop_venta(barras, stop):
    for b in barras.itertuples():
        if b.minimo <= stop:
            return b.ts, min(b.apertura, stop)
    return None, None

def trailing_venta(barras, entrada, pct):
    maximo = entrada
    for b in barras.itertuples():
        stop = maximo * (1 - pct)
        if b.minimo <= stop:
            return b.ts, min(b.apertura, stop), stop
        maximo = max(maximo, b.maximo)
    return None, None, None

def stop_limit_venta(barras, stop, limite, validez="DAY"):
    disparo = None
    for b in barras.itertuples():
        if disparo is None and b.minimo <= stop:
            disparo = b.ts
            if b.apertura > stop:           # sin hueco: sale al stop
                return disparo, b.ts, stop
        if disparo is not None:
            if validez == "DAY" and b.ts.date() > disparo.date():
                return disparo, None, None  # expiró sin ejecutar
            if b.maximo >= limite:
                return disparo, b.ts, max(limite, b.apertura)
    return disparo, None, None

ts, px = stop_venta(barras, 62.50)
print("stop 62,50:      disparo", ts, "· venta a", px)
ts, px, nivel = trailing_venta(barras, entrada, 0.025)
print(f"trailing 2,5 %:  disparo {ts} · nivel {nivel:.2f}",
      f"· venta a {px}")
d, ts, px = stop_limit_venta(barras, 62.50, 62.30)
print("stop-limit DAY:  disparo", d, "· venta:", px)

stop 62,50:      disparo 2024-10-25 13:30:00+00:00 · venta a 60.14
trailing 2,5 %:  disparo 2024-10-25 13:30:00+00:00 · nivel 63.05 · venta a 60.14
stop-limit DAY:  disparo 2024-10-25 13:30:00+00:00 · venta: None

Los tres se disparan en la misma barra, la de la apertura del 25 de octubre (13:30 UTC, 9:30 de Nueva York):

• El stop a 62,50 vende a 60,14, la apertura: 2,36 USD por acción por debajo de su precio. El stop no es un precio garantizado; es la condición para que nazca una orden de mercado.
• El trailing, que había subido su nivel hasta 63,05 con el máximo de 64,67 del 23 de octubre, vende exactamente igual, a 60,14. En un hueco, un stop más ajustado no sirve de nada.
• El stop-limit se dispara, pero su límite de 62,30 queda 1,43 USD por encima del precio más alto del día, 60,87. A las 16:00 expira sin ejecutar y la posición sigue abierta, sin protección.

La figura de la cabecera lo dibuja barra a barra. ¿Y si el stop-limit fuera GTC?

disparo, ts, px = stop_limit_venta(barras, 62.50, 62.30, validez="GTC")
print("se ejecuta", ts, "a", px)
entre = barras[(barras["ts"] > disparo) & (barras["ts"] < ts)]
print("mínimo mientras espera:", entre["minimo"].min(),
      "el", entre.loc[entre["minimo"].idxmin(), "ts"].date())

se ejecuta 2025-01-16 16:55:00+00:00 a 62.3
mínimo mientras espera: 53.51 el 2025-01-03

Se ejecuta casi tres meses después, el 16 de enero de 2025, cuando NOVA vuelve a 62,30. Por el camino la acción llega a 53,51 el 3 de enero, casi 9 USD por debajo del límite. Para una cartera esto es lo contrario de una protección: el stop-limit evita vender mal en el hueco a cambio de no vender en absoluto mientras el precio sigue cayendo.

El ciclo de vida de una orden

Una orden no pasa de «enviada» a «ejecutada» sin más. El bróker y el mercado le devuelven estados, y un sistema real tiene que reaccionar a cada uno: una ejecución parcial deja una posición distinta de la prevista; un rechazo (por saldo, por precio fuera de rango, por mercado cerrado) significa que no hay posición.

stateDiagram-v2
  [*] --> Nueva
  Nueva --> Aceptada
  Nueva --> Rechazada
  Aceptada --> Parcial
  Aceptada --> Ejecutada
  Aceptada --> Cancelada
  Aceptada --> Expirada
  Parcial --> Ejecutada
  Parcial --> Cancelada
  Parcial --> Expirada
  Ejecutada --> [*]
  Cancelada --> [*]
  Rechazada --> [*]
  Expirada --> [*]

Tres estados son finales en cuanto a la orden, aunque no en cuanto a la posición: una orden cancelada o expirada después de una ejecución parcial ha dejado acciones en la cuenta. Modelarlo como una máquina de estados evita los errores más comunes, como cancelar una orden que ya se ejecutó o contar dos veces una ejecución:

TRANSICIONES = {
    "nueva": {"aceptada", "rechazada"},
    "aceptada": {"parcial", "ejecutada", "cancelada", "expirada"},
    "parcial": {"parcial", "ejecutada", "cancelada", "expirada"},
}

class Orden:
    def __init__(self, cantidad):
        self.cantidad, self.ejecutada = cantidad, 0
        self.estado, self.historial = "nueva", ["nueva"]

    def pasa(self, estado):
        if estado not in TRANSICIONES.get(self.estado, set()):
            raise ValueError(f"de {self.estado} no se pasa a {estado}")
        self.estado = estado
        self.historial.append(estado)

    def ejecuta(self, q):
        if self.ejecutada + q > self.cantidad:
            raise ValueError("ejecución mayor que la orden")
        self.ejecutada += q
        lleno = self.ejecutada == self.cantidad
        self.pasa("ejecutada" if lleno else "parcial")

# la IOC de 15.000 acciones a 52,76 contra el libro de las 15:00
o = Orden(15_000)
o.pasa("aceptada")
for _, q in recorre(lado_venta, 15_000, limite=52.76)[0]:
    o.ejecuta(q)
o.pasa("cancelada")     # IOC: el resto se cancela
print(" -> ".join(o.historial), "·", o.ejecutada, "acciones")

nueva -> aceptada -> parcial -> parcial -> cancelada · 11770 acciones

Una orden ejecutada no se puede cancelar. Si el sistema lo intenta (porque recibió tarde la confirmación, por ejemplo), la máquina de estados lo para en lugar de dejar que el error llegue a la cuenta:

o2 = Orden(2_000)
o2.pasa("aceptada")
o2.ejecuta(2_000)
o2.pasa("cancelada")

ValueError: de ejecutada no se pasa a cancelada

Órdenes enlazadas: bracket y OCO

Una OCO (one cancels the other) son dos órdenes enlazadas: cuando una se ejecuta, el sistema cancela la otra. La combinación típica es un objetivo de beneficio (venta limitada por encima) y un stop de pérdidas (venta stop por debajo). Un bracket añade la entrada: el par OCO solo se activa cuando la entrada se ejecuta.

flowchart TB
  E[Entrada limitada] -->|ejecutada| A[Activa OCO]
  A --> TP[Objetivo limitado]
  A --> SL[Stop de pérdidas]
  TP -->|se ejecuta| C1[Cancela el stop]
  SL -->|se ejecuta| C2[Cancela objetivo]

Que el bróker gestione el enlace tiene una ventaja: si el sistema se cae, las órdenes de salida siguen en el servidor. El riesgo está en las ejecuciones parciales: si el objetivo se ejecuta a medias, el stop tiene que reducirse a la cantidad que queda, y no todos los brókeres lo hacen igual. Un sistema que envía brackets debe leer qué hace el suyo y comprobarlo en una cuenta de pruebas.

Otras órdenes que aparecen en los datos

• Iceberg. Una limitada con una parte visible y una reserva oculta que se repone (lección 1.1.3).
• Oculta. Una limitada que no se ve en absoluto en el libro; suele perder prioridad frente a las visibles del mismo precio.
• Pegged (vinculada). Su precio sigue al mejor bid, al mejor ask o al punto medio; es lo que se cruza en el centro oscuro de la lección 1.1.1.
• Algorítmicas del bróker (TWAP, VWAP). No son tipos de orden del mercado, sino programas que parten una orden grande en muchas pequeñas a lo largo del día. Son el origen de muchas de las operaciones de 100 acciones de la cinta.

Ejercicios

1. Calcula el precio medio y los niveles que recorre una venta a mercado de 25.000 acciones contra el libro de las 15:00 y compárala con una compra del mismo tamaño. ¿Por qué no cuestan lo mismo?

for lado, niveles, nombre in ((False, lado_compra, "venta"),
                              (True, lado_venta, "compra")):
    ejec, resto = recorre(niveles, 25_000, compra=lado)
    print(nombre, resumen(ejec, medio))

venta {'acciones': 25000, 'niveles': 3, 'precio_medio': 52.7345, 'sobre_medio_cent': 1.05}
compra {'acciones': 25000, 'niveles': 3, 'precio_medio': 52.7645, 'sobre_medio_cent': 1.95}

2. El 2 de junio de 2025 un sistema compra NOVA a la apertura de las 9:30 (apertura de la primera barra) con un bracket: objetivo un 0,5 % por encima y stop un 0,5 % por debajo. Con las barras de 5 minutos, ¿cuál se ejecuta primero? ¿Qué harías si una misma barra tocara los dos?

todas = pd.read_parquet("nova_barras_5min.parquet")
dia = todas[todas["ts"].dt.date == pd.Timestamp("2025-06-02").date()]
ent = dia["apertura"].iloc[0]
tp, sl = round(ent * 1.005, 2), round(ent * 0.995, 2)
print("entrada", ent, "· objetivo", tp, "· stop", sl)
for b in dia.itertuples():
    toca_tp, toca_sl = b.maximo >= tp, b.minimo <= sl
    if toca_tp or toca_sl:
        print(b.ts.strftime("%H:%M UTC"), "objetivo" if toca_tp else "",
              "stop" if toca_sl else "")
        break

entrada 53.35 · objetivo 53.62 · stop 53.08
13:55 UTC  stop

3. Un sistema diario entra en la apertura con órdenes a mercado y sale con un stop del 3 % GTC. Propón un conjunto de órdenes mejor y justifica cada cambio.