La consola de backtest: prueba estrategias de trading con código

Seguro por diseño. Tu script solo se ejecuta en tu navegador, en un entorno aislado sin acceso a internet: puede leer las velas que recibe y nada más (ni tu cuenta, ni este sitio, ni otras webs). Nada de lo que escribes se ejecuta en nuestros servidores.

Empieza en un minuto

1. Abre cualquier gráfico, por ejemplo EURUSD, y elige la temporalidad que quieres probar (H1, D1…).
2. Pulsa Estrategia en la barra de herramientas del gráfico. La consola se abre debajo del gráfico.
3. Elige una estrategia integrada, por ejemplo Cruce de medias móviles. Se ejecuta al instante: unas flechas en el gráfico marcan cada entrada y salida.
4. Cambia un parámetro (por ejemplo la media lenta de 30 a 50): la prueba vuelve a ejecutarse sola.
5. Mira Resumen para los totales, Operaciones para cada operación y Curva de capital para la cuenta a lo largo del tiempo.
6. Pulsa Editar una copia para convertirla en tu propio script, cámbiala y pulsa Ejecutar prueba (o Ctrl+Enter).

La consola, parte por parte

Ajustes

Cómo leer los resultados

La pestaña Operaciones lista cada operación con su dirección, hora y precio de entrada y salida, tamaño, beneficio en dinero y %, cuántas velas duró, por qué se cerró (señal, stop loss, take profit, invertida, aún abierta al final) y tu comentario. Descargar CSV la exporta a una hoja de cálculo. La Curva de capital muestra la cuenta frente a comprar y mantener. El Log muestra lo que tu script escribió con log().

Cómo se ejecutan las órdenes

• Sin mirar al futuro. Una orden colocada en onBar(i) se ejecuta a la apertura de la vela siguiente (i + 1). Una estrategia nunca puede operar a un precio que no podía conocer.
• Stops dentro de la vela. El stop loss y el take profit se comprueban con el máximo y el mínimo de cada vela. Si ambos podían alcanzarse en la misma vela, cuenta el stop (la suposición prudente). Un hueco que atraviesa un stop se ejecuta a la apertura, como en los mercados reales.
• Una posición a la vez. long() estando en corto cierra el corto y abre un largo («invertido»); long() estando ya en largo solo actualiza los stops que pasas.
• Costes en cada ejecución. El deslizamiento mueve cada precio de ejecución en tu contra; la comisión se cobra a la entrada y a la salida.
• El final. Una operación aún abierta tras la última vela se cierra al último cierre y se marca como «aún abierta al final».

Escribir tu propia estrategia

Una estrategia es un programa corto en JavaScript con dos partes:

1. La parte superior se ejecuta una vez: lee tus parámetros con input(), calcula series completas con ta.* o ind() y dibújalas con plot().
2. function onBar(i) { … } se ejecuta para cada vela, de la más antigua a la más reciente. i es el número de la vela (0 = la más antigua). Decide aquí: long(), short(), exit() o nada.

// 1. once: inputs and series
const len = input("Average length", 50, { min: 5, max: 400 });
const avg = ta.sma(close, len);           // one value per candle
plot(avg, "SMA " + len, "#2F80ED");       // drawn on the price chart

// 2. every candle
function onBar(i) {
  if (avg[i] == null) return;             // the first len - 1 values are null (warming up)
  if (position === 0 && close[i] > avg[i]) long();
  if (position > 0 && close[i] < avg[i]) exit("below the average");
}

Conviene saber desde el principio:

• Las series son arrays, un valor por vela, de la más antigua a la más reciente: close[i] es el cierre de esta vela, close[i - 1] el de la anterior. Las series calculadas son null hasta que tienen suficientes velas; compruébalo antes de usarlas.
• Dentro de onBar(i) solo puedes leer velas hasta i. close[i + 1] detiene la prueba con un error: sería mirar al futuro.
• Usa const y let como siempre; tus propias variables conservan sus valores entre velas (útil para un stop dinámico).
• Los precios están en las unidades del gráfico (para EURUSD 1,0850, para el oro 2650,40); el tiempo, en segundos UTC.

Referencia

Velas y estado actual

Parámetros

Hasta 30 parámetros. Sus valores se guardan con la estrategia y viajan con ella cuando la publicas en una idea.

Cálculos (ta.*)

src es cualquier serie: close, high, otro resultado o tu propio array. Cada función devuelve un array nuevo; nada cambia las velas.

Señales

Órdenes

Salida

Los 71 indicadores del gráfico en código: ind()

ind(id, inputs) calcula cualquier indicador del gráfico exactamente como lo hace el gráfico. Devuelve su primera línea como serie; todas las líneas están en .lines y sus nombres en .names. Los parámetros omitidos toman el valor por defecto indicado. method es uno de SMA, EMA, SMMA, LWMA; price uno de close, open, high, low, median, typical, weighted.

const st = ind("stoch", { k: 14, d: 3, slowing: 3 });   // st = %K, st.lines[1] = %D
const ich = ind("ichimoku");                            // ich.names: Tenkan, Kijun, Span A, Span B, Chikou
const kijun = ich.lines[1];

Ejemplos

Cada ejemplo funciona tal cual: pulsa Copiar, abre la consola, elige Nuevo script…, pega y pulsa Ejecutar prueba. Los resultados dependen del símbolo, la temporalidad y el periodo; los ejemplos enseñan la técnica, no son recomendaciones.

const len = input("Average length", 50, { min: 5, max: 400 });
const avg = ta.sma(close, len);
plot(avg, "SMA " + len, "#2F80ED");

function onBar(i) {
  if (avg[i] == null) return;                 // still warming up
  if (position === 0 && close[i] > avg[i]) long({ comment: "close above the average" });
  if (position > 0 && close[i] < avg[i]) exit("close below the average");
}

const fast = ta.ema(close, input("Fast EMA", 12, { min: 2, max: 200 }));
const slow = ta.ema(close, input("Slow EMA", 26, { min: 3, max: 400 }));
plot(fast, "Fast", "#2F80ED");
plot(slow, "Slow", "#E39B2D");

function onBar(i) {
  if (ta.crossover(fast, slow, i)) long();
  if (ta.crossunder(fast, slow, i)) short();
}

const r = ta.rsi(close, 14);
const sl = input("Stop loss %", 1.5, { min: 0.1, max: 20, step: 0.1 });
const tp = input("Take profit %", 3, { min: 0.1, max: 50, step: 0.1 });

function onBar(i) {
  if (position !== 0) return;                 // one trade at a time
  if (ta.crossover(r, 30, i)) long({ slPct: sl, tpPct: tp, comment: "RSI back above 30" });
  if (ta.crossunder(r, 70, i)) short({ slPct: sl, tpPct: tp, comment: "RSI back below 70" });
}

const a = ta.atr(14);
const hi = ta.highest(high, 20);
const mult = input("Stop (ATR multiple)", 2, { min: 0.5, max: 6, step: 0.5 });

function onBar(i) {
  if (i < 1 || a[i] == null || hi[i - 1] == null || position !== 0) return;
  if (close[i] > hi[i - 1]) {                  // a new 20-candle high
    const stop = close[i] - mult * a[i];
    const target = close[i] + 2 * mult * a[i];
    long({ sl: stop, tp: target, comment: "breakout, risk " + (mult * a[i]).toFixed(5) });
  }
}

const a = ta.atr(14);
const fast = ta.ema(close, 20), slow = ta.ema(close, 50);
let stop = null;

function onBar(i) {
  if (a[i] == null || slow[i] == null) return;
  if (position === 0) {
    stop = null;
    if (ta.crossover(fast, slow, i)) long({ comment: "trend up" });
    return;
  }
  const candidate = close[i] - 3 * a[i];
  if (stop === null || candidate > stop) {     // only ever raise it
    stop = candidate;
    stopLoss(stop);
  }
}

const adx = ind("adx", { period: 14 });      // .lines[0] ADX, [1] +DI, [2] -DI
const plusDI = adx.lines[1], minusDI = adx.lines[2];
const m = ta.macd(close, 12, 26, 9);
const minAdx = input("Minimum ADX", 25, { min: 10, max: 50 });

function onBar(i) {
  if (adx[i] == null || adx[i] < minAdx) return;
  if (ta.crossover(m.macd, m.signal, i) && plusDI[i] > minusDI[i]) long();
  if (ta.crossunder(m.macd, m.signal, i) && minusDI[i] > plusDI[i]) short();
}

const b = ta.bb(close, input("Period", 20, { min: 5, max: 200 }), input("Width", 2, { min: 0.5, max: 4, step: 0.1 }));
plot(b.upper, "Upper", "#8E44AD");
plot(b.lower, "Lower", "#8E44AD");

function onBar(i) {
  if (b.middle[i] == null) return;
  if (position === 0 && close[i] < b.lower[i]) long({ comment: "below the lower band" });
  else if (position === 0 && close[i] > b.upper[i]) short({ comment: "above the upper band" });
  else if (position > 0 && close[i] >= b.middle[i]) exit("middle band");
  else if (position < 0 && close[i] <= b.middle[i]) exit("middle band");
}

const from = input("Start hour (UTC)", 7, { min: 0, max: 23 });
const to = input("End hour (UTC)", 16, { min: 1, max: 24 });
const fast = ta.sma(close, 10), slow = ta.sma(close, 30);

function onBar(i) {
  const hour = new Date(time[i] * 1000).getUTCHours();
  if (position !== 0 && hour >= 20) { exit("end of the day"); return; }
  if (hour < from || hour >= to) return;
  if (ta.crossover(fast, slow, i)) long();
  if (ta.crossunder(fast, slow, i)) short();
}

const k = input("Range multiple", 0.5, { min: 0.1, max: 2, step: 0.1 });
const range = high.map((h, i) => (i ? high[i - 1] - low[i - 1] : null));   // the previous candle's range
const trigger = open.map((o, i) => (range[i] == null ? null : o + k * range[i]));
plot(trigger, "Trigger", "#16A085");

function onBar(i) {
  if (trigger[i] == null) return;
  if (position === 0 && close[i] > trigger[i]) {
    long({ slPct: 1, comment: "close above open + " + k + " x range" });
    log("signal at", close[i], "trigger", trigger[i]);
  } else if (position > 0 && i - entryBar >= 3) {
    exit("held 3 candles");
  }
}

const a = ta.atr(14);
const riskPct = input("Risk per trade %", 1, { min: 0.1, max: 5, step: 0.1 });
const fast = ta.ema(close, 20), slow = ta.ema(close, 50);

function onBar(i) {
  if (a[i] == null || slow[i] == null || position !== 0) return;
  if (ta.crossover(fast, slow, i)) {
    const stopDistance = 2 * a[i];
    const qty = (equity * riskPct / 100) / stopDistance;
    long({ qty: qty, sl: close[i] - stopDistance, tp: close[i] + 3 * stopDistance,
           comment: "risk " + riskPct + "%" });
  }
}

const trend = ta.sma(close, 200), fast = ta.ema(close, 20), r = ta.rsi(close, 14);

function onBar(i) {
  if (trend[i] == null || i < 5) return;
  let dipped = false;
  for (let k = 0; k < 5; k++) if (r[i - k] != null && r[i - k] < 40) dipped = true;
  if (position === 0 && close[i] > trend[i] && dipped && ta.crossover(close, fast, i)) {
    long({ slPct: 2, tpPct: 4, comment: "pullback bought" });
  }
}

Errores y cómo corregirlos

Pruebas en las que puedes confiar

• Añade tus costes. Una estrategia que opera a menudo puede parecer genial sin costes y perder dinero con un spread realista. Rellena siempre el deslizamiento (el spread) y la comisión.
• Usa suficientes operaciones. Con menos de unas 30 operaciones, las cifras son sobre todo azar. Carga más velas o usa una temporalidad menor.
• No te ajustes al pasado. Probar muchos parámetros hasta que el resultado sea perfecto encuentra el ruido de ese periodo, no una regla que funcione. Ajusta con una parte del historial y luego comprueba los mismos parámetros en otro periodo y en otros símbolos.
• Compara con comprar y mantener y mira el drawdown, no solo el beneficio.
• Vigila los extremos. Si una o dos operaciones generan todo el beneficio, la estrategia depende de la suerte.
• Practica antes de arriesgar dinero. Ejecuta la estrategia hacia delante en trading simulado o con repetición de barras, y crea alertas para sus señales.

Los backtests usan velas bid pasadas e ignoran swaps, financiación y spreads que cambian con el mercado. Los resultados pasados no garantizan resultados futuros. Esto no es asesoramiento de inversión.

Guardar, compartir, publicar

• Guardar (con sesión iniciada) conserva hasta 50 estrategias con sus parámetros y ajustes; aparecen en la lista de cada gráfico.
• Publica una idea desde el gráfico y adjunta una estrategia: los lectores pueden abrir tu gráfico y ejecutar la estrategia ellos mismos, con tus parámetros. Ver Ideas.
• Comparte tu análisis con un equipo en un club.
• Descargar CSV en la pestaña Operaciones exporta las operaciones a una hoja de cálculo.
• Para investigación más pesada, descarga las mismas velas con la API de precios (GET /bars) en Python, R o Excel.

Límites

Preguntas