Tutorial de la API Perplexity: Cómo construir paso a paso una respuesta con conexión a tierra en la fuente

API DE PERPLEXITY · TUTORIAL DE PYTHON · 2026

Este tutorial sobre la API Perplexity te muestra cómo crear un script en Python que devuelva una respuesta con fuentes web en las que se puede hacer clic. Utiliza la API de Agent para enviar una pregunta, leer la respuesta, asociar sus marcadores de citas a los ID de las fuentes y exportar un archivo Markdown que puedas revisar.

A lo largo de todo el texto utilizaremos una pregunta: ¿Cómo debería un pequeño proyecto en Python utilizar entornos virtuales y gestionar las dependencias? Empieza con una solicitud básica y, a continuación, añade el análisis de la fuente y los filtros de dominio. Necesitas conocimientos básicos de Python y una cuenta de desarrollador Perplexity con la facturación de la API configurada.

Si tú también utilizas la IA para tus investigaciones y tus trabajos de redacción diarios, Perplexity sobre GlobalGPT Ofrece acceso a través de un espacio de trabajo de IA «todo en uno», lo que reduce la necesidad de cambiar entre distintas herramientas. Ese flujo de trabajo para el usuario final es independiente de la clave de desarrollador y de la facturación de la API que se utilizan aquí.

Respuesta rápida: Utilice el rápido Configuración predeterminada del agente para una primera respuesta basada en la web, leer respuesta.texto_de_salida para conocer la respuesta, y lee el resultados_de_búsqueda elemento en respuesta.salida para las fuentes. Asigna cada marcador en línea a una fuente según el valor devuelto id. Una cita significa que “la respuesta apunta a este resultado”; no garantiza que la página demuestre todas las afirmaciones.

Ejemplo de estado: La sintaxis de la solicitud se ajusta a la documentación oficial consultada el 28 de septiembre de 2026. La herramienta de citación se ha comprobado con datos de muestra sin conexión; no se ha realizado ninguna solicitud de API de pago para este tutorial. Los registros originales que aparecen en la ilustración son ejemplos ilustrativos.

• ¿Qué API Perplexity deberías utilizar?
• Paso 1: Consigue una clave API y configura Python
• Paso 2: Envía tu primera solicitud con conexión a tierra en el lado de la fuente
• Paso 3: Extrae la respuesta y compara sus fuentes
• Paso 4: Mejora la respuesta con los filtros de búsqueda
• Paso 5: Guarda una respuesta completa con fuentes en las que se pueda hacer clic
• Transmisión y salida estructurada
• Costes y errores habituales
• Pasando de un tutorial antiguo de Sonar
• Preguntas frecuentes

Tutorial de la API Perplexity: elige la API adecuada

Se trata de interfaces para desarrolladores. Es posible que el producto de chat ofrezca funciones similares de otra forma; nuestra descripción general de Características de Perplexity describe la experiencia del usuario.

De «Perplexity» Guía rápida de la API oficial agrupa sus productos para desarrolladores en función de la tarea que debas realizar. Elige la superficie más pequeña que genere los datos que tu aplicación realmente necesita.

En este tutorial se ha elegido «Agent» porque el resultado que buscas es una respuesta completa junto con sus fuentes. Para conocer el flujo de trabajo de investigación en general, consulta nuestra guía sobre el uso de Perplexity con fines de investigación.

Acerca de Sonar: La corriente Resumen sobre la migración indica que «Sonar Chat Completions» sigue siendo compatible y recomienda «Agent» para todos los proyectos nuevos. Por lo tanto, este tutorial utiliza «Agent». No se debe deducir que una integración antigua ha dejado de funcionar por el hecho de que en un tutorial anterior se mencione una fecha límite.

Paso 1: Consigue una clave API y configura Python

Crear la clave y preparar la facturación

Abre la consola de la API de Perplexity, elige o crea el proyecto que vas a utilizar, configura la facturación de la API y crea una clave. Guárdala en el servidor. Las API para desarrolladores se facturan por separado de las suscripciones de los usuarios; comprueba el saldo de tu proyecto antes de realizar solicitudes.

Instala el SDK oficial

python -m venv .venv

# macOS/Linux: elige este comando de activación
source .venv/bin/activate

# Windows PowerShell: utiliza este comando en su lugar
.venv\Scripts\Activate.ps1

python -m pip install --upgrade perplexityai

Utiliza Python 3.10 o una versión posterior para el código que aparece a continuación. Activa el entorno mediante el comando correspondiente a tu sistema operativo y, a continuación, instala el SDK. Si PowerShell bloquea la activación, utiliza .venv\Scripts\python.exe en lugar de Python para la instalación y la ejecución de scripts.

El nombre del paquete es perplexityai, mientras que la importación en Python es perplejidad. Utiliza un entorno virtual para que las dependencias de este tutorial no afecten a ningún otro proyecto.

En el ejemplo se utiliza una pregunta sobre programación porque sus afirmaciones pueden contrastarse con la documentación actualizada. Nuestra guía sobre Perplexity para codificación explica cómo encaja el apoyo a la investigación con el hecho de probar el código por uno mismo.

Configura la clave de API como variable de entorno

# macOS/Linux
export PERPLEXITY_API_KEY="tu-clave-aquí"

# Windows PowerShell
$env:PERPLEXITY_API_KEY = "tu-clave-aquí"

El SDK lee PERPLEXIDAD_CLAVE_API cuando crees el cliente. No pegues la clave en un bloc de notas, no la subas a Git ni la envíes a un navegador. Si utilizas un archivo .env a nivel local, mantén ese archivo fuera del control de versiones y cárgalo con la biblioteca de variables de entorno que hayas elegido.

Paso 2: Envía tu primera solicitud con conexión a tierra en el lado de la fuente

Guía de inicio rápido de la API de Agent documentos PUBLICACIÓN https://api.perplexity.ai/v1/agent. Su cliente de Python envuelve la solicitud con client.responses.create(). El rápido La configuración predeterminada habilita la búsqueda en la web de forma predeterminada, lo que permite que el primer ejemplo sea breve.

from perplexity import Perplexity

client = Perplexity()

question = (
    "¿Cómo debería un pequeño proyecto en Python utilizar entornos virtuales"
    "y gestionar las dependencias?"
)

respuesta = cliente.respuestas.crear(
    preajuste="rápido",
    entrada=pregunta,
)

imprimir(respuesta.texto_de_salida)

Guarda el fragmento de código como first_request.py, y a continuación ejecuta python first_request.py en el mismo terminal en el que has configurado la clave. Si la llamada se realiza correctamente, debería aparecer un texto de respuesta que no esté vacío. Si necesitas una confirmación del resultado, pasa al paso de extracción de la fuente; el texto por sí solo no constituye una comprobación completa.

La propiedad de conveniencia texto_de_salida te ofrece el texto de la respuesta definitiva. Conserva también el objeto de respuesta completo: los registros de origen y los detalles de uso se encuentran en la salida mecanografiada, no solo en el párrafo impreso.

La misma solicitud con cURL

curl https://api.perplexity.ai/v1/agent \
  -H "Authorization: Bearer $PERPLEXITY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "preset": "fast",
    "input": "¿Cómo debería un pequeño proyecto en Python utilizar entornos virtuales y gestionar las dependencias?"
  }'

Este ejemplo de cURL utiliza la sintaxis de Bash para macOS/Linux o un shell compatible con Bash. Cada ejecución realiza otra solicitud facturable. Úsalo solo cuando necesites diferenciar un problema del punto final de un problema de Python; no ejecutes todas las versiones solo para seguir el ejemplo.

Equivalente en JavaScript del lado del servidor

Node.js 18+ incluye recoger, por lo que una prueba de funcionamiento del lado del servidor no necesita ninguna biblioteca adicional. Lee el código sin procesar salida elementos de la respuesta JSON; el SDK de Python ofrece la cómoda texto_de_salida accesorio.

const res = await fetch("https://api.perplexity.ai/v1/agent", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.PERPLEXITY_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    preset: "fast",
    input: "¿Cómo debería un pequeño proyecto en Python utilizar entornos virtuales y gestionar las dependencias?"
  })
});
if (!res.ok) throw new Error(`Perplexity HTTP ${res.status}`);
console.log(await res.json());

Paso 3: Extrae la respuesta y compara sus fuentes

Guía oficial sobre cómo citar fuentes distingue la prosa de sus registros probatorios. Las fuentes llegan en un salida elemento de tipo resultados_de_búsqueda. Lee ese artículo en resultados y hacer coincidir cada marcador de cita con el resultado correspondiente id. Un resultado tiene un título y una URL; gestiona los valores que falten antes de mostrarlo.

Ese último detalle es importante. No des por sentado que la “cita 1” sea siempre el primer elemento de una matriz después de que otra herramienta añada un elemento. Realiza una búsqueda por ID y, a continuación, identifica los marcadores que aparecen realmente en la respuesta.

def field(obj, name, default=None):
    return obj.get(name, default) si isinstance(obj, dict); en caso contrario, getattr(obj, name, default)

def source_index(output):
    sources = {}
    for item in output or []:
    if field(item, "type") != "search_results":
        continue
    for result in field(item, "results", []) or []:
            sid, url = field(result, "id"), field(result, "url")
 si sid es None:
 continuar
 key = str(sid)
 si key está en sources y field(sources[key], "url") != url:
                raise ValueError(f"URLs conflictivas para el ID de fuente {key}")
 sources[key] = result
    return sources

sources = source_index(response.output)
print(sources.get("7"))  # Un ID de fuente, no la posición 7 del array

El script completo que aparece a continuación reconoce [1] y [web:1], los formatos de cita documentados para los ajustes preestablecidos habituales. La herramienta anterior gestiona tanto objetos del SDK como diccionarios, y rechaza las URL conflictivas asignadas al mismo ID. No renumera los resultados ni infiere una fuente que falte.

Para un análisis más detallado sobre la calidad de las citas, consulta nuestro Guía de precisión en las citas de Perplexity. Una referencia es un registro de seguimiento; tu aplicación sigue necesitando una política para las páginas obsoletas, las URL duplicadas y las afirmaciones sin fundamento.

Por ejemplo, si la matriz devuelta contiene el ID 2 seguido del ID 7, el marcador [7] debe enlazar con el ID 7. Si la misma URL aparece en los ID 7 y 9, puedes mostrar esa URL una sola vez conservando ambos ID. Si el ID 8 nunca llega, mantén [8] visible y marcarlo como sin coincidencia.

Paso 4: Mejora la respuesta con los filtros de búsqueda

Una vez que la consulta básica funcione, limita la búsqueda cuando tu pregunta tenga un ámbito de aplicación bien definido. En el caso de los paquetes de Python, la documentación del lenguaje y la guía de creación de paquetes son mejores puntos de partida que un tutorial cualquiera.

respuesta = client.responses.create(
    preset="fast",
    input=(
 "¿Cómo debería un pequeño proyecto en Python utilizar entornos virtuales "
 "y gestionar las dependencias? Cita las directrices que utilices."
    ),
    herramientas=[
 {
 "tipo": "búsqueda_web",
 "filtros": {
 "filtro_de_dominio_de_búsqueda": [
 "docs.python.org",
                    "packaging.python.org",
 ]
 },
 }
    ],
)

El filtro forma parte de la configuración de la herramienta de búsqueda en la web. La documentación sobre la migración también describe filtro_por_antigüedad_de_búsqueda para preguntas en las que el factor tiempo es determinante. Recurre a la «reciencia» cuando la pregunta dependa de publicaciones o noticias recientes; una combinación muy limitada de ámbito y fecha puede dejarte con muy poca evidencia.

Si tienes alguna pregunta sobre los lanzamientos del último mes, añade "search_recency_filter": "mes" al lado de filtro_de_búsqueda_por_dominio. No lo incluyas en el ejemplo del entorno virtual: la documentación estable puede tener una fecha de publicación anterior. Si pasas de un modelo preestablecido a uno seleccionado directamente, incluye explícitamente la herramienta de búsqueda en la web.

Compara los resultados filtrados con los no filtrados durante el desarrollo. Si la respuesta cambia, anota el motivo: es posible que un filtro elimine contexto útil o que elimine páginas con poca autoridad que distraían al modelo. Se trata de una decisión basada en la calidad, no de una garantía de que todas las páginas restantes sean correctas.

Si tu aplicación solo necesita enlaces ordenados por relevancia y fragmentos, llama a la función API de búsqueda y realiza tú mismo la síntesis. Esa separación puede facilitar la revisión y el almacenamiento en caché. Para una comparación más amplia con Google, consulta En qué se diferencia Perplexity de Google.

Paso 5: Guarda una respuesta completa con fuentes en las que se pueda hacer clic

Guarda lo siguiente como perplexity_tutorial.py. Es autónomo: incluye el ayudante de fuentes, aplica el filtro de dominio de la documentación de Python, convierte los marcadores de citas que coinciden en enlaces, agrupa las URL duplicadas sin perder los ID y guarda la respuesta completa del SDK junto con el Markdown.

from pathlib import Path
from collections import defaultdict
from urllib.parse import urlsplit
import json
import re

PREGUNTA = (
 "¿Cómo debería un pequeño proyecto en Python utilizar entornos virtuales"
 "y gestionar las dependencias?"
)
# Admite los formatos documentados [1] y [web:1] en las respuestas en prosa.
CITATION_RE = re.compile(r"(?<!!)\[(?:web:)?(\d+)\](?!\()")

def field(obj, name, default=None):
 return obj.get(name, default) if isinstance(obj, dict) else getattr(obj, name, default)

def source_index(output):
 sources = {}
 for item in output or []:
 if field(item, "type") != "search_results":
 continue
 for result in field(item, "results", []) or []:
 sid, url = field(result, "id"), field(result, "url")
 if sid is None:
 continue
 key = str(sid)
 if key in sources and field(sources[key], "url") != url:
 raise ValueError(f"URLs conflictivas para el ID de fuente {key}")
 sources[key] = result
 return sources

def safe_url(value):
 if not isinstance(value, str):
 return None
 parsed = urlsplit(value)
 si parsed.scheme no está en ("http", "https") o no es parsed.netloc:
 return None
 # Proteger un destino entre corchetes angulares de Markdown.
 return value.replace("", "").replace(" ", "")

def md_label(valor):
 return re.sub(r"([\\\[\]])", r"\\\1", str(valor).replace("\n", " "))

def export_markdown(respuesta, salida, pregunta=PREGUNTA):
 fuentes = source_index(salida)
 citados = list(dict.fromkeys(CITATION_RE.findall(respuesta)))
 missing = [
 sid for sid in cited
 if sid not in sources or not safe_url(field(sources[sid], "url"))
 ]
 def link(match):
 sid = match.group(1)
 url = safe_url(field(sources.get(sid, {}), "url"))
 return f"[{match.group(0)[1:-1]}]()" si url; en caso contrario, match.group(0)

 # Conservar cada ID cuando la misma URL aparezca bajo diferentes ID.
 grouped = defaultdict(list)
 titles = {}
 for sid in cited:
 source = sources.get(sid, {})
 url = safe_url(field(source, "url"))
 if url:
 grouped[url].append(sid)
 titles.setdefault(url, field(source, "title") or url)

 líneas = ["# Respuesta basada en fuentes", "", pregunta, "",
 CITATION_RE.sub(enlace, respuesta), "", "## Fuentes citadas", ""]
 for url, ids in grouped.items():
 lines.append(f"- ID {', '.join(ids)}: [{md_label(titles[url])}]()")
 si hay faltas:
 lines.append("- ID de fuentes sin coincidencia o inutilizables: " + ", ".join(missing))
 si no se ha citado:
 lines.append("- No se han reconocido citas en el texto; la evidencia no se ha verificado.")
 lines.extend(["", "Los enlaces a las fuentes deben revisarse; la coincidencia de los ID no verifica las afirmaciones."])
 return "\n".join(líneas) + "\n"

def main():
 from perplexity import Perplexity
 respuesta = Perplexity().responses.create(
 preset="fast",
 input=QUESTION,
 tools=[{"type": "web_search", "filters": {
 "search_domain_filter": ["docs.python.org", "packaging.python.org"]
 }}],
 )
 respuesta = respuesta.output_text or ""
 if not respuesta.strip():
 raise RuntimeError("No se ha devuelto ningún texto de respuesta; comprueba el estado de la respuesta y los errores.")
 Path("perplexity-response.json").write_text(
 response.model_dump_json(indent=2), encoding="utf-8"
 )
 Path("perplexity-answer.md").write_text(
 export_markdown(respuesta, respuesta.output), encoding="utf-8"
 )
 print("Se han guardado los archivos "perplexity-answer.md" y "perplexity-response.json'")

if __name__ == "__main__":
 main()

Correr python perplexity_tutorial.py desde el directorio de tu proyecto. Escribe perplexity-answer.md y perplexity-response.json allí, sustituyendo los archivos anteriores con esos nombres. El archivo Markdown contiene la pregunta, la respuesta enlazada, las fuentes citadas y cualquier ID sin asignar. El archivo JSON conserva el resultado devuelto y el uso para el diagnóstico.

El analizador se centra en las formas documentadas de un solo marcador en prosa. No es un analizador completo de Markdown: si tu aplicación requiere Markdown arbitrario, ejemplos de código o citas como, por ejemplo, [1,2], añade un renderizador que reconozca la sintaxis y pruebas para ese formato. No reinterpretes en silencio los marcadores desconocidos.

Comprueba si la página enlazada respalda la respuesta

En este ejemplo, comprueba si la documentación citada explica realmente el aislamiento del entorno y la instalación de dependencias. Un enlace a la página web de Python es menos útil que la sección correspondiente de la documentación. Si una respuesta recomienda un comando concreto, comprueba el sistema operativo y la versión de Python antes de ejecutarlo. Mark afirma que el texto citado no justifica que la pregunta se mantenga como «sin resolver».

Añade una salida en streaming o estructurada cuando sea necesario

Transmisión

El streaming mejora la latencia percibida en una interfaz de chat. La guía de migración de Agent documenta eventos de cambio de texto como, por ejemplo: response.output_text.delta. Muestra esos cambios a medida que vayan llegando, pero recopila también los elementos de la respuesta final para que tu interfaz de usuario pueda mostrar las fuentes una vez que se haya completado la respuesta. Un simple flujo de texto no constituye por sí solo una lista de fuentes.

Lo que sigue es solo una visualización de texto. Conserva la exportación sin transmisión en tiempo real para tu primer registro de origen completo; una implementación de transmisión en tiempo real en producción también debe recopilar los eventos de herramienta y de salida, y gestionar las ejecuciones interrumpidas o fallidas.

stream = client.responses.create(
    preset="fast", input=question, stream=True
)
for event in stream:
    if event.type == "response.output_text.delta":
 print(event.delta, end="", flush=True)

Salida estructurada

Utiliza una respuesta estructurada cuando el código posterior necesite campos como respuesta, nota de confianza y preguntas_de_seguimiento. Mantén los ID de origen en un campo independiente o conserva la salida original de Agent para que tu esquema no oculte las pruebas. Valida el esquema con tus propios casos de prueba antes de utilizarlo en un flujo de trabajo.

La referencia de migración conserva formato_de_respuesta con tipo: "json_schema" para una salida estructurada. Define los campos obligatorios y no permitas propiedades inesperadas cuando sea necesario. Las comprobaciones de validez del esquema se centran en la forma, no en la veracidad: los identificadores de origen deben seguir correspondiendo a los registros reales devueltos, y una etiqueta de confianza generada por el modelo no es una medida de precisión.

Costes y errores habituales de la API Perplexity

Página oficial de precios de Perplexity, consultado el 28 de septiembre de 2026, distingue entre los tokens del modelo «Agent» y las invocaciones de herramientas. A continuación se indican los cargos en USD por herramientas y búsquedas. El rápido Configuración predeterminada del agente y search_type: "rápido" Existen diferentes opciones de configuración; no deduzcas la velocidad de búsqueda a partir del nombre del ajuste preestablecido.

Ejemplo: El coste de 1.000 consultas estándar de búsqueda en la web más 1.000 recuperaciones de URL $3.00 en gastos de herramientas ($2.50 + $0.50), antes de los tokens de modelo u otros cargos. Se trata de una carga de trabajo estimada, no de un coste medido para el tutorial. Una sola solicitud del agente puede activar varias herramientas. Cuando esté disponible, comprueba uso.coste.coste_total en la respuesta completada.

La API de búsqueda factura las solicitudes que se completan con éxito, incluidas aquellas que no devuelven resultados; el precio de la solicitud no conlleva ningún coste adicional por tokens. Los costes de los agentes dependen de los tokens de los modelos y de las herramientas. Mantén separadas estas unidades de facturación al comparar un flujo de trabajo de respuesta con un flujo de trabajo de solo búsqueda.

Para comparar presupuestos de API, nuestra Guía de precios de la API Perplexity aporta información adicional, aunque la página oficial de precios sigue siendo la fuente de referencia para conocer las tarifas actuales.

Pasando de un tutorial antiguo de Sonar

Muchos resultados de búsqueda siguen mostrando el diseño anterior de «Chat Completions». La guía de migración para agentes utiliza una correspondencia conceptual directa. Si estás comparando las etiquetas del modelo para consumidores con los ajustes predefinidos de la API, consulta nuestra guía explicativa sobre qué utiliza LLM Perplexity ofrece información contextual, pero no sustituye a la documentación de la API de Agent.

Lee la retransmisión en directo Resumen sobre la migración y datos sobre la migración antes de modificar el código de producción. Las asignaciones predefinidas son un punto de partida, no una garantía de que los modelos antiguos y los nuevos ofrezcan una calidad, una latencia o un coste idénticos.

Preguntas frecuentes

¿La API Perplexity es gratuita?

Las API se facturan según el consumo, tal y como se indica en la documentación actual de inicio rápido y de precios. No des por sentado que una suscripción de consumidor, una prueba o un crédito promocional hacen que todas las solicitudes a la API sean gratuitas.

¿Necesito Perplexity Pro para utilizar la API?

El acceso a la API y el plan Pro para consumidores son productos independientes. Crea credenciales de API y comprueba la facturación de la API correspondiente a la cuenta de desarrollador que tengas previsto utilizar.

¿Debería utilizar la API de Agent o la API de Search?

Elige «Agente» cuando desees una respuesta completa y fundamentada con fuentes. Elige «Búsqueda» cuando tu aplicación deba encargarse de la clasificación, el filtrado y la síntesis. Puedes combinar «Búsqueda» con tu propio modelo si necesitas un control estricto sobre cada paso de generación.

¿Puedo llamar a Perplexity desde JavaScript?

Sí. Utiliza el ejemplo de Node.js del lado del servidor que se muestra más arriba o el SDK oficial de JavaScript. Guarda la clave en el servidor. Al leer JSON sin procesar, revisa los elementos de salida tipificados y aplica las mismas reglas de asignación de ID de origen.

¿Se garantiza que las citas de Perplexity sean correctas?

No. Una cita te indica a qué resultado de la búsqueda se refiere la respuesta. Tu solicitud o el revisor deben comprobar igualmente la actualidad, la fiabilidad y si la página respalda exactamente esa afirmación.

¿Por qué mi analizador no ha encontrado ninguna fuente?

Revisa los tipos de resultados sin procesar, comprueba que se haya realizado la búsqueda en la web y verifica si tu expresión regular coincide con el formato de cita del ajuste preestablecido. Si no aparece ningún marcador, guarda la respuesta como «sin verificar» e investiga la solicitud en lugar de añadir un enlace a ciegas.

¿Puede una clave API GlobalGPT sustituir a una clave API Perplexity?

GlobalGPT es un espacio de trabajo de IA «todo en uno» para el uso diario de la IA. Su suscripción y el acceso a los modelos son independientes de la cuenta de desarrollador, la clave de API y los créditos de API de Perplexity; este tutorial de Python utiliza la cuenta de desarrollador.

Una lista de comprobación práctica para el lanzamiento

• Crea una clave del lado del servidor y confirma la facturación de la API.
• Ejecuta la versión mínima rápido solicitarlo antes de añadir filtros o iniciar la reproducción en streaming.
• Guarda la respuesta completa, no solo el texto visible de la respuesta.
• Emparejar los marcadores de citas con los identificadores de fuente devueltos y señalar los marcadores que no coincidan.
• Revisa las páginas citadas para comprobar que respalden las afirmaciones, que estén actualizadas y que no haya URL duplicadas.
• Vuelve a consultar la documentación sobre el agente en producción, los precios y la migración antes de la implementación.

Ahora ya dispones del modelo básico para una integración fiable de la API Perplexity: formula una pregunta concreta, deja que la API del agente realice la búsqueda, mantén la respuesta y las pruebas juntas, y haz que cada cita sea auditable. A partir de aquí, añade el almacenamiento en caché, los reintentos y tus propias reglas de revisión en torno al mismo flujo de trabajo de ID de fuente.