Logo
Nuevos usuarios de RPC: 35% de descuento el primer mesVer oferta
OnFinality Learn
Rendimiento y optimización11 min de lectura

Cómo elegir el mejor RPC de BSC: un método de evaluación reproducible

Un marco práctico basado en mediciones para seleccionar un endpoint RPC de BNB Smart Chain según tu carga de trabajo, presupuesto de latencia y requisitos de datos.

TL;DR

No existe un único mejor endpoint RPC de BSC: la elección correcta depende del presupuesto de latencia de tu carga de trabajo, la mezcla de solicitudes, las necesidades de archivo y la tolerancia a fallos. Este artículo te ofrece un método reproducible para medir tú mismo los endpoints candidatos, interpretar los resultados frente al rápido ritmo de bloques de BNB Smart Chain y decidir entre opciones compartidas, dedicadas y autoalojadas. Ejecutarás pruebas de latencia, rendimiento y corrección, crearás una tabla de resultados y la usarás para preseleccionar proveedores. Para obtener una recomendación directa de endpoint en lugar de una metodología, usa RPC Assistant.

Qué significa realmente "el mejor RPC de BSC" para tu carga de trabajo

BNB Smart Chain produce bloques en un ritmo inferior al segundo, por lo que un endpoint RPC que es rápido en promedio pero que ocasionalmente se bloquea puede dejar a tu aplicación un bloque o más atrás. El mejor endpoint para una billetera que lee saldos no es el mejor endpoint para un indexador que reproduce eth_getLogs a lo largo de millones de bloques, y ninguno de los dos es el mejor endpoint para un bot de trading que transmite transacciones en medio de la congestión.

Este artículo trata "el mejor" como una decisión que tomas a partir de evidencia: define la mezcla de solicitudes, mide los endpoints candidatos en condiciones realistas y compara los resultados con umbrales explícitos. No clasifica proveedores. Para obtener una recomendación breve y directa sobre qué endpoint o proveedor usar para una red y un caso de uso específicos, consulta RPC Assistant.

  • Las cargas de trabajo con muchas lecturas (billeteras, paneles) se centran en la latencia y la consistencia de eth_call y eth_getBalance.
  • Las cargas de trabajo con muchos logs (indexadores, analítica) se centran en los límites de rango de eth_getLogs, la profundidad de archivo y el rendimiento sostenido.
  • Las cargas de trabajo con muchas escrituras (bots, relayers) se centran en la propagación de transacciones, la visibilidad del mempool y la exposición a MEV.
  • Todas las cargas de trabajo se centran en la corrección: un endpoint rápido que devuelve datos obsoletos o incorrectos es peor que uno más lento pero correcto.

Supuestos y requisitos previos antes de hacer el benchmark

El procedimiento siguiente supone que tienes una URL RPC de la mainnet o testnet de BSC para cada endpoint candidato, una máquina en la región donde se origina tu tráfico de producción o cerca de ella, y permiso para enviar unos miles de solicitudes. Usa la testnet para pruebas destructivas o de gran volumen cuando sea posible; usa la mainnet solo para pruebas de solo lectura.

También necesitas conocer tu chain ID y confirmar que el endpoint lo informa correctamente. La mainnet de BSC usa el chain ID 56 (0x38) y la testnet usa el 97 (0x61). Un candidato que devuelve un chain ID incorrecto o un eth_blockNumber obsoleto debe descartarse antes de las pruebas de latencia. Si aún estás configurando un entorno de pruebas, la guía de la testnet de BNB Smart Chain cubre faucets y configuración.

  • Un RPC_URL por candidato, almacenado en variables de entorno, nunca codificado directamente.
  • Una máquina cliente con salida de red estable; evita hacer benchmarks a través de VPN o Wi-Fi compartido.
  • Una ventana de prueba fija (por ejemplo, 10 minutos) aplicada de forma idéntica a cada candidato.
  • Una tabla de resultados preparada antes de empezar para que registres números brutos, no impresiones.

El modelo mental: latencia, rendimiento, frescura y corrección

Toda evaluación de RPC se reduce a cuatro dimensiones. La latencia es el tiempo de ida y vuelta de una sola solicitud, normalmente reportado como mediana y p95 o p99. El rendimiento es cuántas solicitudes por segundo soporta el endpoint antes de que aparezcan errores o se infle la latencia. La frescura es la rapidez con la que el endpoint refleja el último bloque. La corrección es si las respuestas coinciden con un nodo de referencia.

Estas dimensiones se compensan entre sí. Un endpoint público compartido puede tener una mediana de latencia excelente desde una región cercana, pero limitarte bajo una carga en ráfaga. Un nodo dedicado te da un rendimiento predecible, pero cuesta más y sigue dependiendo de tu interconexión. Un endpoint de archivo puede servir bien las consultas históricas mientras se retrasa en las lecturas de la cabeza de la cadena. Mide cada dimensión por separado y luego combínalas en una puntuación ponderada según tu carga de trabajo.

Paso 1: Verificar la identidad de la cadena y la frescura de la cabeza

Antes de medir la velocidad, confirma que cada endpoint está en la cadena correcta y sigue la cabeza. Ejecuta lo siguiente contra cada candidato y registra el chain ID, el número de bloque informado y la hora del reloj. Repite tres veces con unos segundos de diferencia; el número de bloque de un endpoint saludable debería avanzar en cada muestra.

Compara el número de bloque informado con un endpoint de referencia en el que confíes. Un candidato que está sistemáticamente más de dos o tres bloques por detrás de la referencia no es adecuado para lecturas sensibles a la latencia, independientemente de lo rápido que devuelvan las solicitudes individuales.

for url in "$RPC_A" "$RPC_B" "$RPC_C"; do
  echo "== $url"
  curl -s -X POST "$url" \
    -H 'Content-Type: application/json' \
    -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
  echo
  curl -s -X POST "$url" \
    -H 'Content-Type: application/json' \
    -d '{"jsonrpc":"2.0","id":2,"method":"eth_blockNumber","params":[]}'
  echo
  date +%s
  sleep 3
done

Paso 2: Medir la distribución de latencia de una sola solicitud

La latencia mediana oculta la cola que perjudica a producción. Envía un número fijo de solicitudes de lectura idénticas, por ejemplo eth_getBalance para una dirección conocida en el último bloque, y registra cada tiempo de ida y vuelta. Calcula la mediana, p95 y p99. Ejecuta el mismo script contra cada candidato desde la misma máquina en la misma ventana.

El script siguiente usa Node.js con la API fetch integrada y escribe una línea JSON por solicitud para que puedas posprocesarla con cualquier herramienta. Reemplaza RPC_URL y el marcador de posición de la dirección con tus propios valores. No reutilices una sola conexión si quieres modelar el comportamiento de arranque en frío; el comportamiento predeterminado de fetch es suficiente para una primera pasada.

const RPC_URL = process.env.RPC_URL;
const ADDRESS = process.env.ADDRESS;
const N = 200;

async function probe(i) {
  const body = JSON.stringify({
    jsonrpc: '2.0', id: i, method: 'eth_getBalance',
    params: [ADDRESS, 'latest']
  });
  const start = performance.now();
  const res = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body
  });
  const json = await res.json();
  const ms = performance.now() - start;
  console.log(JSON.stringify({ i, ms, ok: !json.error, status: res.status }));
}

(async () => {
  for (let i = 0; i < N; i++) await probe(i);
})();

Paso 3: Probar el rendimiento y el comportamiento ante errores bajo carga

La latencia bajo carga ligera dice poco sobre el comportamiento durante una ráfaga. Aumenta la concurrencia por pasos (por ejemplo, 1, 5, 20 y 50 solicitudes en vuelo) y registra las solicitudes por segundo, la tasa de errores y la latencia p95 en cada paso. Deja de aumentar la concurrencia cuando la tasa de errores supere un umbral que definas de antemano, como el 1 por ciento.

Registra los resultados en una tabla como la siguiente. Deja las celdas en blanco hasta que las hayas medido; no estimes. La tabla es el artefacto que usarás para comparar candidatos y justificar una decisión entre compartido y dedicado.

Paso 4: Validar las consultas de logs y la profundidad de archivo

Si tu aplicación indexa eventos, eth_getLogs suele ser la restricción determinante. Prueba el mayor rango de bloques que necesita tu carga de trabajo contra cada candidato y registra si la solicitud tiene éxito, cuánto tarda y si el recuento de resultados coincide con una referencia. Muchos endpoints compartidos limitan los rangos de logs o deshabilitan eth_getLogs por completo, por lo que esta prueba puede descartar un candidato rápidamente.

Para las consultas históricas, prueba un bloque de varios meses atrás y confirma que el endpoint devuelve datos en lugar de un error de poda. El acceso a archivo suele ser una función de pago; si lo necesitas, compara proveedores por profundidad de archivo y coste de consulta en lugar de por la latencia principal. La guía de endpoints RPC explica en qué se diferencian los nodos de archivo, completos y podados.

curl -s -X POST "$RPC_URL" \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_getLogs","params":[{"fromBlock":"0x1","toBlock":"latest","address":"0x0000000000000000000000000000000000000000"}]}' \
  | head -c 400

Interpretar los resultados frente al ritmo de bloques de BSC

Los bloques de BSC llegan rápido, por lo que tu presupuesto de latencia debería expresarse en bloques, no solo en milisegundos. Si tu tiempo de ida y vuelta p95 supera el intervalo de bloque, tu aplicación a veces leerá un estado que tiene un bloque de antigüedad incluso cuando el endpoint está saludable. Para una carga de trabajo de trading o liquidación, eso es un problema de corrección; para un panel, puede ser aceptable.

Usa tus números medidos para establecer umbrales: por ejemplo, exige un p95 por debajo de un intervalo de bloque para las lecturas de la cabeza de la cadena, y exige cero errores en tu concurrencia máxima esperada. Si ningún endpoint compartido cumple el umbral, esa es la señal para evaluar un nodo dedicado. La opción de nodo dedicado te ofrece capacidad de un solo inquilino e interconexión predecible, a un coste mayor.

Solución de problemas de artefactos comunes en los benchmarks

La mayoría de los resultados de benchmark engañosos provienen del arnés de pruebas, no del endpoint. Si un candidato parece drásticamente más rápido, comprueba si está devolviendo datos en caché u obsoletos, si tu cliente está reutilizando conexiones de forma diferente y si la ventana de prueba se superpuso con un periodo de congestión de red.

Si los resultados son ruidosos entre ejecuciones, aumenta el tamaño de la muestra y ejecuta los candidatos en orden intercalado en lugar de secuencial, para que los efectos de la hora del día se compartan. Si un candidato devuelve errores solo bajo concurrencia, inspecciona el cuerpo de la respuesta en busca de mensajes de límite de tasa en lugar de suponer un fallo de red. Si los números de bloque no coinciden entre candidatos, espera a la finalidad antes de comparar; una diferencia de un bloque durante el funcionamiento normal es esperable.

  • Datos obsoletos: compara eth_blockNumber con una referencia en el mismo momento.
  • Límite de tasa: busca HTTP 429 o códigos de error JSON-RPC en el cuerpo de la respuesta.
  • Reutilización de conexiones: mantén la configuración del cliente idéntica entre candidatos.
  • Sesgo regional: ejecuta la prueba desde la región donde realmente están tus usuarios o servidores.

Limitaciones y compensaciones de cualquier medición única

Un benchmark es una instantánea. La infraestructura del proveedor cambia, la interconexión se desplaza y tu propio perfil de tráfico evoluciona, por lo que un resultado válido este mes puede no mantenerse el próximo trimestre. Trata las mediciones como un dato de entrada para la decisión, no como un veredicto permanente, y vuelve a ejecutar la prueba cuando cambies de región, escales o añadas un nuevo tipo de solicitud.

Tampoco hay soluciones gratuitas en todas las dimensiones. Los endpoints compartidos son baratos y a menudo rápidos, pero limitan bajo ráfagas. Los nodos dedicados son predecibles, pero requieren planificación de capacidad. El autoalojamiento da el máximo control, pero traslada la carga operativa a tu equipo. La compensación correcta depende de cuánto te cuesta una solicitud fallida, lo cual es una cuestión de negocio, no técnica.

Próximos pasos: de la preselección a la configuración de producción

Una vez que tu tabla tenga números reales, preselecciona dos candidatos que cumplan tus umbrales y configúralos detrás de una capa de failover para que la caída de un solo endpoint no tumbe tu aplicación. Mantén el script de prueba en tu repositorio y prográmalo para que se ejecute periódicamente contra los endpoints de producción, alertando cuando el p95 o la tasa de errores crucen tus umbrales.

Para obtener recomendaciones concretas de endpoints y proveedores adaptadas a tu red y carga de trabajo, usa RPC Assistant. Para comparar planes y límites de solicitudes, consulta precios de RPC, y para confirmar qué redes son compatibles, revisa la lista de redes compatibles. Si tus mediciones muestran que la capacidad compartida es el cuello de botella, revisa la opción de nodo dedicado antes de comprometerte con un contrato a largo plazo.

Nunca te preocupes por la infraestructura nuevamente

OnFinality elimina la carga pesada de DevOps para que puedas construir de forma más inteligente y rápida.

Comenzar