¿Comprar, mantener o vender? Analizador de acciones con Python

La mayoría de las herramientas de análisis de acciones te dan un número y esperan que confíes en él.

Escribes un ticker, una caja negra hace algo, y sale un "Comprar" o un "Vender". Sin explicación. Sin visibilidad de qué impulsó la puntuación. Sin forma de comprobar si el modelo simplemente premió a una empresa por una métrica vistosa mientras ignoraba tres señales de alerta.

Eso está al revés. Una herramienta de análisis útil debería convertirte en mejor analista, no sustituir tu juicio por la opinión de otro disfrazada de matemáticas.

Si eres:

• un desarrollador que quiere combinar APIs financieras con un LLM,
• un inversor cansado de saltar entre diez pestañas del navegador para armar una tesis,
• o alguien construyendo herramientas fintech que necesita un sistema de puntuación transparente en lugar de un número misterioso,

esto es para ti.

Cómo analizar una acción antes de comprar

Esto es lo que realmente pasa cuando la mayoría de la gente intenta analizar una acción antes de comprarla.

Abren el ticker en una app de bróker. Ven el PER. Buscan en Google "¿es [ticker] una buena acción?". Leen tres opiniones contradictorias en Reddit. Cierran el portátil más confundidos que cuando empezaron.

El problema no es la falta de datos. Los datos están por todas partes ahora, APIs gratuitas, apps de bróker, webs de noticias financieras.

El problema es que nadie los estructura.

El crecimiento sin contexto de valoración parece emocionante. La valoración sin contexto de calidad parece barata por alguna razón. Una sola calificación de "Comprar" de un analista anónimo no te dice nada sobre el negocio subyacente.

El análisis de acciones no necesita más información. Necesita un marco que obligue a cada dato a responder una pregunta específica, y que luego combine esas respuestas con honestidad.

Eso es lo que vamos a construir aquí: una herramienta en Python que trae datos financieros reales a través de EODHD, puntúa una empresa en cinco dimensiones, y le entrega la interpretación (no las matemáticas) a Claude. Al final, tendrás código funcional que puedes apuntar a cualquier ticker.

Los 5 factores que más importan

Toda decisión de inversión, te des cuenta o no, se reduce a cinco preguntas.

1. Calidad del negocio. ¿Convierte esta empresa ingresos en beneficio y caja reales, de forma consistente?
2. Crecimiento. ¿Se está haciendo realmente más grande el negocio, o un buen trimestre distorsionó la imagen?
3. Salud financiera. ¿Podría esta empresa sobrevivir a un mal año sin romperse?
4. Valoración. ¿Estás pagando un precio justo por lo que recibes, o una prima por una buena historia?
5. Momentum. ¿La trayectoria está mejorando, se mantiene estable, o está girando a la baja?

Ninguna de estas preguntas tiene una única respuesta correcta. Pero cada una tiene una puntuación defendible y calculable, y esa es la diferencia entre una opinión y un análisis.

Obteniendo datos financieros con EODHD

He probado un puñado de proveedores de datos financieros para proyectos como este, y siempre vuelvo a EODHD por una razón: una sola llamada a la API te da fundamentales, estados financieros, histórico de resultados, y estimaciones de analistas para un solo ticker, en lugar de coser cinco endpoints distintos.

A través del endpoint fundamentals, una sola petición devuelve:

• Perfil de la empresa y clasificación por sector
• Múltiplos de valoración (PER, PEG, EV/EBITDA, Precio/Ventas)
• Métricas de rentabilidad (ROE, ROA, márgenes)
• Cuenta de resultados, balance, y flujo de caja completos (trimestral y anual)
• Histórico de resultados con BPA real frente a estimado y porcentaje de sorpresa
• Calificaciones de analistas y precios objetivo

Aquí está la función sobre la que se construye todo lo demás en esta herramienta:

import os
import requests
EODHD_API_KEY = os.environ.get("EODHD_API_KEY", "demo")
BASE_URL = "https://eodhd.com/api"

def get_fundamentals(ticker: str) -> dict:
    """Pull the full fundamentals payload for a single ticker."""
    url = f"{BASE_URL}/fundamentals/{ticker}"
    params = {"api_token": EODHD_API_KEY, "fmt": "json"}
    resp = requests.get(url, params=params, timeout=30)
    resp.raise_for_status()
    return resp.json()

Todo lo que viene después (calidad, crecimiento, salud, valoración, momentum) lee de este mismo payload. Sin viajes de ida y vuelta extra.

Consigue los datos detrás de este analizador
EODHD te da fundamentales, estados financieros completos, y estimaciones de analistas a través de una sola API, con un plan gratuito para probar.
→ Empieza con EODHD

Tres pequeños ayudantes hacen el trabajo repetitivo en cada función de puntuación de abajo: traer un campo a través de varios años fiscales, normalizar un número en crudo a una subpuntuación de 0-100, y comprobar si una métrica creció de forma consistente.

def yearly_series(f, statement, field, n=6):
    data = f["Financials"][statement]["yearly"]
    dates = sorted(data.keys())[-n:]
    return [(d, float(data[d][field])) for d in dates if data[d].get(field) is not None]
def latest_yearly(f, statement):
    data = f["Financials"][statement]["yearly"]
    return data[sorted(data.keys())[-1]]

def normalize(value, floor, ceiling):
    """Linear-scale a raw metric into a 0-100 sub-score."""
    if value is None:
        return None
    score = (value - floor) / (ceiling - floor) * 100
    return max(0, min(100, score))

def growth_consistency(values):
    """Share of consecutive periods that grew. 1.0 = grew every year."""
    if len(values) < 2:
        return None
    ups = sum(1 for i in range(1, len(values)) if values[i] > values[i - 1])
    return ups / (len(values) - 1)

Todas las funciones de puntuación a partir de aquí asumen que estas cuatro ya están importadas.

Paso 1: Midiendo la calidad del negocio

Una empresa puede hacer crecer sus ingresos cada año y seguir siendo un mal negocio, si ese crecimiento nunca se convierte en beneficio o caja real.

La calidad del negocio responde a una pregunta más estrecha: cuando esta empresa hace una venta, ¿cuánto de eso se queda realmente?

Medimos seis cosas:

• Retorno sobre el capital (ROE), cómo de eficiente es la empresa convirtiendo el capital de los accionistas en beneficio
• Margen operativo, rentabilidad de las operaciones principales, antes del ruido de financiación e impuestos
• Margen neto, lo que queda después de todo
• Margen de flujo de caja libre, el porcentaje de ingresos que se convierte en caja que la empresa realmente puede usar, para recompras, pagar deuda, o reinvertir
• Consistencia del FCF, si el flujo de caja libre creció la mayoría de los años o subió una vez y se revirtió
• Consistencia de beneficios, la proporción de los últimos años en que la empresa fue realmente rentable

Esas dos últimas importan más de lo que la gente les reconoce. Una empresa con un año increíble y cuatro mediocres no es de alta calidad. Tuvo suerte una vez.

def calculate_quality_score(f: dict) -> dict:
    h = f["Highlights"]
    revenue = yearly_series(f, "Income_Statement", "totalRevenue")
    fcf = yearly_series(f, "Cash_Flow", "freeCashFlow")
    net_income = yearly_series(f, "Income_Statement", "netIncome")
    roe = h.get("ReturnOnEquityTTM") or 0
    op_margin = h.get("OperatingMarginTTM") or 0
    net_margin = h.get("ProfitMargin") or 0
    fcf_margin = fcf[-1][1] / revenue[-1][1] if revenue and fcf else None
    fcf_consistency = growth_consistency([v for _, v in fcf])
    profit_consistency = sum(1 for _, v in net_income if v > 0) / len(net_income)
    sub_scores = {
        "roe": normalize(roe, 0.0, 0.40),
        "operating_margin": normalize(op_margin, 0.0, 0.45),
        "net_margin": normalize(net_margin, 0.0, 0.35),
        "fcf_margin": normalize(fcf_margin, 0.0, 0.35),
        "fcf_consistency": normalize(fcf_consistency, 0.0, 1.0),
        "profit_consistency": normalize(profit_consistency, 0.0, 1.0),
    }
    weights = {"roe": .20, "operating_margin": .20, "net_margin": .15,
               "fcf_margin": .15, "fcf_consistency": .15, "profit_consistency": .15}
    final = sum(sub_scores[k] * weights[k] for k in sub_scores)
    return {"score": round(final), "components": sub_scores}

normalize() mapea una métrica en crudo a una subpuntuación de 0-100 usando un suelo y un techo. Un ROE del 40% consigue un 100 pleno. Un ROE del 0% o negativo consigue 0. Todo lo que hay en medio es lineal. Ninguna métrica puede por sí sola empujar la puntuación a 100. Se pondera y se promedia con otras cinco, que es todo el sentido: un número genial no esconde cuatro mediocres.

Paso 2: Midiendo el crecimiento

El crecimiento es donde la mayoría de las herramientas de "análisis de acciones con IA" hacen trampa en silencio. Ven un gran número de BPA trimestral y lo tratan como prueba de un negocio próspero.

A veces lo es. A veces es una ganancia puntual por vender un activo, un crédito fiscal, o revalorizar una participación, nada de lo cual te dice algo sobre si el negocio principal se está expandiendo.

Miramos cinco señales: crecimiento trimestral de ingresos, CAGR de ingresos a 3 años (que suaviza cualquier trimestre irregular), crecimiento trimestral del BPA, crecimiento del flujo de caja libre, y consistencia de ingresos a lo largo de los últimos años fiscales.

El número de crecimiento del BPA recibe un ajuste importante: tiene un tope.

def calculate_growth_score(growth: dict) -> dict:
    # One-off items (asset sales, equity stakes, tax credits) can distort
    # quarterly EPS by 100%+ without reflecting the underlying business.
    # Capping prevents those spikes from dominating the score.
    eps_yoy = growth["eps_growth_yoy"]
    eps_yoy_capped = max(-0.5, min(eps_yoy, 0.60)) if eps_yoy is not None else None
    sub_scores = {
        "revenue_growth": normalize(growth["revenue_growth_yoy"], -0.05, 0.35),
        "revenue_cagr_3y": normalize(growth["revenue_cagr_3y"], 0.0, 0.35),
        "eps_growth": normalize(eps_yoy_capped, -0.20, 0.40),
        "fcf_growth": normalize(growth["fcf_growth_yoy"], -0.20, 0.40),
        "consistency": normalize(growth["revenue_consistency"], 0.0, 1.0),
    }
    weights = {"revenue_growth": .20, "revenue_cagr_3y": .25, "eps_growth": .20,
               "fcf_growth": .20, "consistency": .15}
    final = sum(sub_scores[k] * weights[k] for k in sub_scores)
    return {"score": round(final), "components": sub_scores}

Una acción que reporta un 300% de crecimiento del BPA por una ganancia puntual no debería superar automáticamente a una empresa que compone ingresos de forma constante al 20% al año. El tope mantiene la puntuación honesta. Vas a ver exactamente por qué esto importa más adelante, cuando comparemos dos empresas reales.

Paso 3: Comprobando la salud financiera

El crecimiento y la calidad te dicen si un negocio es bueno. La salud financiera te dice si puede sobrevivir a equivocarse en algo.

Toda recesión, subida de tipos, o mal ciclo de producto acaba poniendo a prueba el balance de una empresa. Las que tienen demasiada deuda y demasiado poco efectivo se ven forzadas a tomar malas decisiones: recortar I+D, diluir a los accionistas, vender activos en el peor momento posible.

def calculate_financial_health_score(f: dict) -> dict:
    bs = latest_yearly(f, "Balance_Sheet")
    fcf = yearly_series(f, "Cash_Flow", "freeCashFlow")[-1][1]
    equity = float(bs.get("totalStockholderEquity") or 0)
    lt_debt = float(bs.get("longTermDebt") or 0)
    current_assets = float(bs.get("totalCurrentAssets") or 0)
    current_liab = float(bs.get("totalCurrentLiabilities") or 1)
    cash = float(bs.get("cash") or 0) + float(bs.get("shortTermInvestments") or 0)
    ebitda = f["Highlights"].get("EBITDA") or 0
    debt_to_equity = lt_debt / equity if equity else None
    current_ratio = current_assets / current_liab
    net_debt_to_ebitda = (lt_debt - cash) / ebitda if ebitda else None
    fcf_to_debt = fcf / lt_debt if lt_debt else 1.0
    sub_scores = {
        "debt_to_equity": 100 - normalize(debt_to_equity, 0.0, 1.0),
        "current_ratio": normalize(current_ratio, 0.5, 3.0),
        "net_debt_to_ebitda": 100 - normalize(net_debt_to_ebitda, -1.0, 3.0),
        "fcf_to_debt": normalize(fcf_to_debt, 0.0, 2.0),
        "cash_cushion": normalize(cash / current_liab, 0.0, 3.0),
    }
    weights = {"debt_to_equity": .25, "current_ratio": .20, "net_debt_to_ebitda": .20,
               "fcf_to_debt": .20, "cash_cushion": .15}
    final = sum(sub_scores[k] * weights[k] for k in sub_scores)
    return {"score": round(final), "components": sub_scores}

Dos cosas que vale la pena explicar: deuda-sobre-capital y deuda-neta-sobre-EBITDA están invertidas (100 - normalize(...)) porque en estas métricas, menos es mejor. Una empresa con deuda neta negativa (más caja que deuda) puntúa cerca del máximo. Una empresa muy apalancada puntúa cerca del mínimo, sin importar lo rápido que esté creciendo.

Paso 4: ¿Está la acción cara o barata?

Este es el paso que la mayoría de los tutoriales de Python sobre análisis de acciones se saltan por completo, y es el que más importa.

Una puntuación de calidad de 91/100 no significa nada si estás pagando un PER de 60x por ella. La valoración no es un juicio sobre la empresa. Es un juicio sobre el precio que pagarías hoy, en relación a lo que el negocio realmente está entregando.

Miramos el PER futuro, el PEG (PER ajustado por el crecimiento esperado), el EV/EBITDA (neutral respecto a la estructura de capital, útil para comparar empresas con distintos niveles de deuda), Precio-sobre-Flujo-de-Caja-Libre, y Precio-sobre-Ventas.

def calculate_valuation_score(f: dict) -> dict:
    v, h = f["Valuation"], f["Highlights"]
    fcf = yearly_series(f, "Cash_Flow", "freeCashFlow")[-1][1]
    price_fcf = h["MarketCapitalization"] / fcf
    # Lower is cheaper for every one of these metrics, so the normalized
    # score gets inverted: a lower P/E produces a HIGHER valuation score.
    sub_scores = {
        "forward_pe": 100 - normalize(v.get("ForwardPE"), 10, 40),
        "peg": 100 - normalize(h.get("PEGRatio"), 0.5, 2.5),
        "ev_ebitda": 100 - normalize(v.get("EnterpriseValueEbitda"), 8, 25),
        "price_fcf": 100 - normalize(price_fcf, 15, 45),
        "price_sales": 100 - normalize(v.get("PriceSalesTTM"), 2, 12),
    }
    weights = {"forward_pe": .20, "peg": .25, "ev_ebitda": .20,
               "price_fcf": .20, "price_sales": .15}
    final = sum(sub_scores[k] * weights[k] for k in sub_scores)
    return {"score": round(final), "components": sub_scores}

Aquí está la regla que gobierna toda esta sección: una empresa de alta calidad nunca debería recibir automáticamente una alta puntuación de valoración. Están respondiendo preguntas distintas. Una pregunta "¿es este un buen negocio?". La otra pregunta "¿estoy pagando un precio justo por él hoy?". Una gran empresa y una gran inversión no son la misma afirmación.

Paso 5: ¿Están los fundamentales mejorando o deteriorándose?

La puntuación de momentum no es una señal de trading. No intenta predecir el precio de la semana que viene.

Pregunta algo más simple: ahora mismo, ¿la trayectoria de esta empresa apunta hacia arriba, se mantiene plana, o va hacia abajo?

Combinamos cinco señales: dónde se sitúa la media móvil de 50 días dentro del rango de 52 semanas, si la media de 50 días está por encima o por debajo de la de 200 días (un filtro de tendencia básico), la sorpresa media de resultados en los últimos cuatro trimestres reportados, el crecimiento trimestral de ingresos, y la proporción de analistas que califican la acción como Comprar o Comprar Fuerte.

def calculate_momentum_score(f: dict) -> dict:
    t, h = f["Technicals"], f["Highlights"]
    reported = sorted(
        [(d, v) for d, v in f["Earnings"]["History"].items()
         if v.get("surprisePercent") is not None],
        reverse=True,
    )[:4]
    avg_surprise = sum(v["surprisePercent"] for _, v in reported) / len(reported)
    ratings = f["AnalystRatings"]
    total = sum(ratings.get(k, 0) for k in
                ["StrongBuy", "Buy", "Hold", "Sell", "StrongSell"])
    analyst_skew = (ratings.get("StrongBuy", 0) + ratings.get("Buy", 0)) / total
    price_position = (t["50DayMA"] - t["52WeekLow"]) / (t["52WeekHigh"] - t["52WeekLow"])
    trend = 70 if t["50DayMA"] > t["200DayMA"] else 30
    sub_scores = {
        "price_position": normalize(price_position, 0.0, 1.0),
        "trend": trend,
        "earnings_surprise": normalize(avg_surprise, -15, 15),
        "revenue_growth": normalize(h.get("QuarterlyRevenueGrowthYOY"), -0.05, 0.30),
        "analyst_skew": normalize(analyst_skew, 0.4, 1.0),
    }
    weights = {"price_position": .20, "trend": .20, "earnings_surprise": .25,
               "revenue_growth": .20, "analyst_skew": .15}
    final = sum(sub_scores[k] * weights[k] for k in sub_scores)
    label = "Improving" if final >= 65 else "Stable" if final >= 45 else "Deteriorating"
    return {"score": round(final), "label": label, "components": sub_scores}

Ten en cuenta la misma advertencia del Paso 2, que reaparece aquí: un porcentaje de sorpresa enorme puede venir de una ganancia puntual en lugar de una fortaleza operativa real. Vamos a ver exactamente eso en la comparación de abajo.

Construyendo la puntuación de inversión

Cada una de las cinco puntuaciones recibe su propio peso en el número final:

Categoría	Peso	Por qué
Calidad del negocio	25%	La base. Todo lo demás se construye sobre un negocio real y rentable.
Crecimiento	20%	Confirma que el negocio se está expandiendo, no solo siendo eficiente.
Salud financiera	20%	Determina si la empresa sobrevive a un mal año.
Valoración	20%	Determina si el precio de hoy tiene sentido.
Momentum	15%	La señal más reciente, y la menos fiable. Ponderada la más baja a propósito.

Los datos que faltan no rompen el cálculo. Cada función de subpuntuación solo promedia los componentes que realmente llegaron de la API. Un PEG que falta (habitual en empresas no rentables) simplemente se excluye del promedio de valoración en lugar de convertirse en cero en silencio o hacer fallar el script.

Usando Claude para interpretar los resultados

Esta es la parte donde muchos proyectos de "analizador de acciones con IA" se equivocan. Le piden a un LLM que genere una puntuación directamente, lo que significa que la puntuación es lo que sea que al modelo le apeteciera generar ese día, no algo que puedas auditar o reproducir.

Aquí, Claude nunca ve los estados financieros en crudo y nunca inventa un número. Recibe las puntuaciones ya terminadas como JSON estructurado y escribe la explicación en lenguaje llano alrededor de ellas.

import anthropic
client = anthropic.Anthropic()
def interpret_report(report: dict) -> str:
    prompt = f"""
You are a financial analyst explaining a stock scoring report to a retail investor.
Do not change or second-guess the scores below. Use them as ground truth.
{report}
Write four short sections:
1. What the company does well
2. Where it's weak
3. The single biggest risk right now
4. What would need to change for the thesis to strengthen or weaken
Do not recommend buying or selling. Describe trade-offs, not conclusions.
"""
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=800,
        messages=[{"role": "user", "content": prompt}],
    )
    return response.content[0].text

La división del trabajo importa aquí. Python hace las matemáticas porque las matemáticas deberían ser reproducibles: ejecútalo dos veces, obtén la misma puntuación. Claude hace la redacción porque el lenguaje es donde un LLM realmente añade valor, traduciendo cinco números y una docena de ratios en algo sobre lo que un humano puede actuar.

META: ejemplo completo de análisis de acciones

Vamos a ejecutar esto contra un ticker real. Esto es lo que devuelve el analizador para META, traído en vivo desde EODHD:

META: Investment Analysis
Business Quality      77/100
Growth                47/100
Financial Health      69/100
Valuation             63/100
Momentum              57/100  (Stable)

Overall Score          64/100

Repasando qué impulsó realmente cada número:

Calidad (77/100). El ROE de META está en 29,85%, el margen operativo en 34,83%, y ha sido rentable todos los años del dataset. Este es un negocio genuinamente bien gestionado. Lo único que frena la puntuación de subir más es la consistencia del FCF, el flujo de caja libre bajó este año, lo que nos lleva al crecimiento.

Crecimiento (47/100). Los ingresos suben un 28% interanual, lo que por sí solo puntuaría bien. Pero el BPA trimestral cayó un 13,4% y el flujo de caja libre bajó casi un 15% respecto al año anterior. La razón es visible directamente en el estado de flujo de caja: el capex casi se duplicó, de 37.300 M$ a 69.700 M$, mientras la empresa vuelca dinero en infraestructura de IA. Eso no es necesariamente malo. Es una apuesta por capacidad futura. Pero significa menos caja disponible hoy, y la puntuación de crecimiento lo refleja con honestidad en lugar de fijarse solo en la línea halagadora de ingresos.

Salud financiera (69/100). La deuda-sobre-capital es un conservador 27%, el current ratio es un saludable 2,6x, y la empresa tiene más caja que deuda en términos netos. Este es un negocio que puede absorber un año difícil sin estrés financiero.

Valoración (63/100). Un PER futuro de 19,9 y un PEG de 0,89 (por debajo de 1,0 generalmente indica que la acción está razonablemente valorada respecto a su crecimiento) son las cifras destacadas aquí. El Precio-sobre-FCF en aproximadamente 32,6x es la única métrica que tira la puntuación hacia abajo, una consecuencia directa de esa misma caída del FCF por el aumento del capex.

Momentum (57/100, Estable). La acción cotiza en la mitad inferior de su rango de 52 semanas, y la media de 50 días está justo por debajo de la media de 200 días, una leve tendencia bajista. El sentimiento de los analistas se mantiene fuertemente positivo (80% Comprar o Comprar Fuerte), y las sorpresas de resultados en los últimos cuatro trimestres promedian un modesto 2,6%, mezclando un fallo y tres aciertos.

Leyendo el panel en conjunto: META sigue siendo un negocio de alta calidad y financieramente conservador que cotiza a un precio razonable. La caída del crecimiento no es una señal de alarma por sí sola, es el coste visible de una apuesta de infraestructura que el mercado todavía no ha puesto en precio en ninguna dirección. Ese es exactamente el tipo de matiz que una sola señal de "Comprar/Vender" borraría.

Comparando dos acciones

Ejecutar el mismo analizador contra Alphabet (GOOGL) hace concretos los trade-offs.

META       GOOGL
Quality               77          85
Growth                47          65
Financial Health      69          73
Valuation             63          52
Momentum              57          81

Overall               64          71

Alphabet lidera en cuatro de las cinco categorías. Un ROE del 48,7%, ingresos que han crecido todos los años del dataset sin un solo año a la baja, y una puntuación de momentum reforzada por una acción que cotiza cerca de su máximo de 52 semanas.

Pero mira la valoración: META puntúa más alto (63 frente a 52). Alphabet cotiza a un Precio-sobre-FCF cercano a 57,7x, casi el doble del 32,6x de META, y un Precio-sobre-Ventas de 9,5 frente al 6,6 de META. Alphabet es el negocio más fuerte sobre el papel ahora mismo. También tiene el precio de uno.

Hay una segunda cosa que vale la pena detectar aquí, porque es exactamente la trampa que los Pasos 2 y 5 se construyeron para evitar. El crecimiento trimestral del BPA de Alphabet aparece en aproximadamente un 294% interanual, y su sorpresa media de resultados en los últimos cuatro trimestres llega al 87%. Ambos números están casi por completo inflados por ganancias puntuales, no por una repentina triplicación del negocio principal de publicidad y cloud. La puntuación de crecimiento pone un tope a ese pico de BPA antes de que pueda dominar el número. La puntuación de momentum no aplica el mismo tope a la sorpresa de resultados, y vale la pena saberlo si estás leyendo el 81 al pie de la letra: parte es fortaleza operativa real, parte es ruido contable de inversiones revalorizadas.

Ninguna de las dos empresas recibe una etiqueta de "ganadora" aquí. Alphabet ofrece más fortaleza de negocio por un precio más alto. META ofrece un margen de seguridad menor en calidad a cambio de una valoración más razonable. Ese trade-off, no un solo número mezclado, es la decisión de inversión real.

Limitaciones del análisis de acciones con IA

Vale la pena ser directo sobre lo que esta herramienta no hace.

No tiene ninguna visión sobre fosos competitivos, calidad de la dirección, o riesgo regulatorio, cosas que no aparecen limpiamente en un estado financiero. Es retrospectiva por naturaleza; cada ratio aquí viene del último trimestre o año reportado, no de lo que pase después. Las sorpresas de resultados y el crecimiento del BPA pueden distorsionarse por partidas puntuales, como acaba de mostrar el ejemplo de Alphabet. Y no dice nada sobre tu situación específica: tu horizonte temporal, la concentración de tu cartera actual, tu tolerancia al riesgo.

Esto es un punto de partida para la investigación, no un sustituto de ella.

Reflexión final

Los datos financieros no deberían tomar la decisión de inversión por ti. Deberían dejarte mejor informado cuando la tomes tú mismo.

Una puntuación de calidad de 91 y una puntuación de valoración de 40 no son contradictorias. Son dos respuestas honestas a dos preguntas distintas. Aprender a sostener ambas en tu cabeza a la vez, en lugar de colapsarlas en un solo "Comprar" o "Vender", es la mayor parte de lo que separa a un inversor sistemático de alguien reaccionando al titular que leyó esa mañana.

Preguntas frecuentes

¿Es EODHD gratis de usar para este tipo de análisis?
EODHD ofrece un plan gratuito con llamadas a la API limitadas, suficiente para probar el endpoint de fundamentales y construir un prototipo. El uso en producción con muchos tickers requiere un plan de pago.

¿Puedo ejecutar esto en cualquier acción, no solo tickers de EE. UU.?
Sí. EODHD cubre mercados globales, así que el formato del ticker solo necesita el sufijo correcto (.US, .LSE, .PA, etcétera). La lógica de puntuación en sí no cambia.

¿Por qué usar Claude en lugar de simplemente imprimir las puntuaciones en crudo?
Las puntuaciones te dicen qué pasó. Un LLM es útil para explicar por qué podría importar y qué vigilar a continuación, en lenguaje llano, sin cambiar los números subyacentes.

¿En qué se diferencia esto de un screener de acciones?
Un screener filtra miles de acciones por umbrales simples. Esta herramienta profundiza en un solo ticker a la vez, explicando el razonamiento detrás de cada puntuación en lugar de solo ordenar empresas unas contra otras.

Construye tu propia versión de este analizador
Cada puntuación de este artículo salió de una sola llamada a la API de EODHD por ticker: fundamentales, estados financieros, histórico de resultados, y estimaciones de analistas en una sola respuesta. Obtendrás:

• Cuenta de resultados, balance, y datos de flujo de caja completos, trimestrales y anuales
• Histórico de resultados con BPA real frente a estimado y porcentaje de sorpresa
• Un plan gratuito para probar el mismo endpoint usado en este recorrido
  → Empieza con EODHD

¿Construyendo algo con datos financieros?
Si eres una empresa de APIs o fintech buscando explicar tu producto con contenido práctico y centrado en código en lugar de marketing genérico, escribo piezas exactamente como esta.
→ Ve más de mi trabajo

¿Buscas contenido técnico para tu empresa? Puedo ayudarte — LinkedIn · kevinmenesesgonzalez@gmail.com