> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sorsa.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Sorsa Score y análisis de criptomonedas

# Sorsa Score y análisis de redes sociales de criptomonedas

Sorsa mantiene una base interna de cuentas de X relacionadas con criptomonedas: proyectos, influencers, líderes de opinión, fondos de capital riesgo y sus empleados. Estos endpoints ofrecen datos adicionales a los perfiles habituales: una puntuación de influencia, categorías de seguidores y actividad reciente de seguimiento dentro del ecosistema.

Están diseñados para investigar proyectos, evaluar influencers, descubrir iniciativas y analizar comunidades. Ayudan a estudiar la legitimidad de un proyecto, el peso de un influencer o qué proyectos emergentes atraen la atención de fondos.

> **Empieza gratis:** todos los endpoints están disponibles con las primeras 100 solicitudes, sin tarjeta ni caducidad. Una revisión con puntuación, variaciones, categorías y principales seguidores requiere unas cuatro llamadas por cuenta: aproximadamente 25 cuentas antes de necesitar un plan.

> **Nota:** estas funciones también están disponibles en la interfaz visual de [Sorsa](https://api.sorsa.io/). La API da acceso programático a los mismos datos para tus herramientas.

***

## Qué es Sorsa Score

Es una métrica numérica que refleja cuántas cuentas influyentes del sector siguen a una cuenta y qué influencia tienen. No se basa en el total de seguidores, la calidad del contenido, el aspecto del perfil ni la verificación, sino en la red de relaciones: quién te sigue y qué peso tiene.

Características principales:

* **Importa más la calidad que la cantidad.** Unos pocos seguidores con más de 1.000 puntos aportan más que decenas con 200. Se premia el reconocimiento de figuras establecidas, no el seguimiento masivo.
* **Se excluyen las cuentas de seguimiento recíproco y masivo.** Sorsa detecta y filtra cuentas que inflan artificialmente sus seguidores; no contribuyen a la puntuación.
* **El contenido, el diseño y la marca azul no afectan directamente.** El contenido de calidad puede atraer seguidores influyentes con el tiempo, por lo que puede haber correlación.
* **La puntuación cambia.** Varía cuando cuentas influyentes siguen o dejan de seguir. `/score-changes` muestra los cambios semanales y mensuales.

Una puntuación alta señala reconocimiento en el ecosistema. Una puntuación baja en una cuenta que afirma ser un actor destacado merece investigación.

***

## Endpoints

| Endpoint                | Devuelve                                                       |
| :---------------------- | :------------------------------------------------------------- |
| `GET /score`            | Puntuación actual                                              |
| `GET /score-changes`    | Variación de la última semana y mes                            |
| `GET /followers-stats`  | Seguidores por categoría: influencers, proyectos y fondos      |
| `GET /top-followers`    | Los 20 principales seguidores por puntuación                   |
| `GET /top-following`    | Las 20 principales cuentas seguidas por puntuación             |
| `GET /new-followers-7d` | Cuentas del sector que empezaron a seguir al usuario en 7 días |
| `GET /new-following-7d` | Cuentas del sector que el usuario empezó a seguir en 7 días    |

Todos utilizan GET y requieren exactamente uno de `username`, `user_id` o `user_link`.

***

## Consultar Sorsa Score

**Endpoint:** `GET /v3/score`

```bash theme={null}
curl "https://api.sorsa.io/v3/score?username=VitalikButerin" \
  -H "ApiKey: YOUR_API_KEY"
```

```json theme={null}
{"score": 1843.7}
```

```python theme={null}
import requests

API_KEY = "YOUR_API_KEY"

def get_score(username):
    resp = requests.get(
        "https://api.sorsa.io/v3/score",
        headers={"ApiKey": API_KEY},
        params={"username": username},
    )
    resp.raise_for_status()
    return resp.json()["score"]

print(f"Vitalik's Sorsa Score: {get_score('VitalikButerin')}")
```

Proporciona uno de los tres identificadores. Una puntuación mayor indica más reconocimiento entre influencers, proyectos y fondos del sector. La primera consulta de cuentas con muchos seguidores puede tardar algo más.

***

## Seguir la evolución de la puntuación

**Endpoint:** `GET /v3/score-changes`

Devuelve el cambio semanal y mensual. Un crecimiento rápido puede señalar un proyecto emergente; una caída, una pérdida de reconocimiento.

```python theme={null}
def get_score_changes(username):
    resp = requests.get(
        "https://api.sorsa.io/v3/score-changes",
        headers={"ApiKey": API_KEY},
        params={"username": username},
    )
    resp.raise_for_status()
    return resp.json()

changes = get_score_changes("some_crypto_project")
print(f"Week delta:  {changes['week_delta']:+}")
print(f"Month delta: {changes['month_delta']:+}")
```

Respuesta:

```json theme={null}
{
  "week_delta": 12,
  "month_delta": 24
}
```

Un `week_delta` positivo indica que la puntuación aumentó en los últimos 7 días. Un valor negativo puede indicar que seguidores influyentes dejaron de seguir o perdieron puntuación propia.

**Requisito:** la cuenta debe estar ya registrada en la base de Sorsa. Las cuentas nuevas o no seguidas anteriormente no tienen historial de puntuación.

***

## Seguidores por categoría

**Endpoint:** `GET /v3/followers-stats`

Clasifica los seguidores de la base de Sorsa en influencers individuales, proyectos y fondos de capital riesgo y sus empleados.

```python theme={null}
def get_follower_breakdown(username):
    resp = requests.get(
        "https://api.sorsa.io/v3/followers-stats",
        headers={"ApiKey": API_KEY},
        params={"username": username},
    )
    resp.raise_for_status()
    return resp.json()

stats = get_follower_breakdown("some_crypto_project")
print(f"Total followers (Sorsa DB): {stats['followers_count']}")
print(f"  Influencers: {stats['influencers_count']}")
print(f"  Projects:    {stats['projects_count']}")
print(f"  VCs:         {stats['venture_capitals_count']}")
```

Respuesta:

```json theme={null}
{
  "followers_count": 16,
  "influencers_count": 12,
  "projects_count": 3,
  "venture_capitals_count": 1,
  "user_protected": false
}
```

Aquí `followers_count` cuenta seguidores incluidos en la base de criptomonedas de Sorsa, no todos los de X. Una cuenta con 50.000 seguidores puede tener solo 200 relevantes registrados.

Este desglose ayuda a investigar proyectos. Si uno afirma contar con respaldo de fondos, cabe esperar cuentas de ese tipo entre sus seguidores. La ausencia de seguidores de fondos y proyectos pese a afirmar alianzas es una señal que conviene revisar.

***

## Los 20 principales seguidores y cuentas seguidas

**Endpoint:** `GET /v3/top-followers`

Devuelve los 20 seguidores con mayor Sorsa Score para conocer qué cuentas influyentes siguen el perfil.

**Endpoint:** `GET /v3/top-following`

Devuelve las 20 cuentas seguidas con mayor puntuación y muestra a quién presta atención el usuario.

```python theme={null}
def get_top_followers(username):
    resp = requests.get(
        "https://api.sorsa.io/v3/top-followers",
        headers={"ApiKey": API_KEY},
        params={"username": username},
    )
    resp.raise_for_status()
    return resp.json().get("users", [])


def get_top_following(username):
    resp = requests.get(
        "https://api.sorsa.io/v3/top-following",
        headers={"ApiKey": API_KEY},
        params={"username": username},
    )
    resp.raise_for_status()
    return resp.json().get("users", [])


# Who are the biggest names following this project?
top = get_top_followers("some_crypto_project")
print("Top followers by Sorsa Score:")
for u in top[:10]:
    print(f"  @{u['username']} (Score {u.get('score', 0)}, {u['followers_count']:,} followers)")
    print(f"    {u.get('description', '')[:60]}")
```

Las respuestas tienen estructuras diferentes:

* `/top-followers` devuelve `TopFollowersResponse`: perfiles compactos con `score`, la puntuación propia de cada seguidor. Omite campos de perfiles completos como `location` y `bio_urls`.
* `/top-following` devuelve `FollowersResponse`: objetos `Follower` con campos estándar y `followerDate`, la fecha de seguimiento. No incluye `score`.

Para completar perfiles de seguidores destacados, envía sus nombres a `/info-batch`.

***

## Nuevos seguidores y cuentas seguidas: últimos 7 días

**Endpoint:** `GET /v3/new-followers-7d`

Devuelve cuentas de la base de Sorsa que empezaron a seguir al usuario en los últimos 7 días.

**Endpoint:** `GET /v3/new-following-7d`

Devuelve cuentas de esa base que el usuario empezó a seguir durante el mismo periodo.

```python theme={null}
def get_new_followers_7d(username):
    resp = requests.get(
        "https://api.sorsa.io/v3/new-followers-7d",
        headers={"ApiKey": API_KEY},
        params={"username": username},
    )
    resp.raise_for_status()
    return resp.json().get("users", [])


def get_new_following_7d(username):
    resp = requests.get(
        "https://api.sorsa.io/v3/new-following-7d",
        headers={"ApiKey": API_KEY},
        params={"username": username},
    )
    resp.raise_for_status()
    return resp.json().get("users", [])


new_followers = get_new_followers_7d("some_crypto_project")
print(f"New crypto followers this week: {len(new_followers)}")
for u in new_followers:
    print(f"  @{u['username']} followed on {u.get('followerDate', 'unknown')}")
```

Ambos devuelven `FollowersResponse` con objetos `Follower` y `followerDate`.

### Dependencia de la base de datos

1. **La cuenta objetivo debe estar registrada.** Sin historial previo, el endpoint no puede determinar qué relaciones son nuevas.
2. **Solo se muestran relaciones con cuentas de la base.** Los seguidores ajenos al sector no aparecen. Estos endpoints analizan específicamente relaciones entre cuentas de criptomonedas.

Los datos son relevantes para ese ecosistema, pero no sustituyen a `/followers` cuando necesitas todos los seguidores. Consulta [Seguidores y cuentas seguidas](https://docs.sorsa.io/es/followers-and-following).

***

## Aplicaciones prácticas

### Investigar un proyecto

Combina endpoints para construir un perfil de confianza:

```python theme={null}
def due_diligence_report(username):
    """Quick due diligence check for a crypto project."""
    score = get_score(username)
    changes = get_score_changes(username)
    stats = get_follower_breakdown(username)
    top = get_top_followers(username)

    print(f"Due Diligence: @{username}")
    print(f"{'='*40}")
    print(f"Sorsa Score:   {score}")
    print(f"  Week change: {changes['week_delta']:+}")
    print(f"  Month change:{changes['month_delta']:+}")
    print()
    print(f"Crypto followers: {stats['followers_count']}")
    print(f"  Influencers: {stats['influencers_count']}")
    print(f"  Projects:    {stats['projects_count']}")
    print(f"  VCs:         {stats['venture_capitals_count']}")
    print()

    if top:
        print(f"Top followers by Score:")
        for u in top[:5]:
            print(f"  @{u['username']} (Score {u.get('score', 0)}, {u['followers_count']:,} followers)")
    else:
        print("No significant crypto followers found - investigate further.")

    # Red flags
    flags = []
    if score < 10:
        flags.append("Very low Score - minimal recognition in crypto")
    if stats["venture_capitals_count"] == 0 and stats["projects_count"] == 0:
        flags.append("No VC or project followers - claims of partnerships may be false")
    if changes["month_delta"] < -20:
        flags.append("Score dropping fast - influential followers are leaving")

    if flags:
        print(f"\nRed flags:")
        for f in flags:
            print(f"  - {f}")

    return score, stats, top


due_diligence_report("some_crypto_project")
```

### Comparar proyectos

```python theme={null}
projects = ["project_a", "project_b", "project_c"]

print(f"{'Project':<20} {'Score':>7} {'Week':>6} {'Influencers':>12} {'Projects':>9} {'VCs':>5}")
print("-" * 65)

for handle in projects:
    score = get_score(handle)
    changes = get_score_changes(handle)
    stats = get_follower_breakdown(handle)

    print(f"@{handle:<19} {score:>7.1f} {changes['week_delta']:>+6} "
          f"{stats['influencers_count']:>12} {stats['projects_count']:>9} "
          f"{stats['venture_capitals_count']:>5}")
```

### Seguir la actividad de fondos

Observa qué proyectos empieza a seguir una cuenta de un fondo. Puede señalar futuras inversiones o colaboraciones:

```python theme={null}
vc_accounts = ["a16z_crypto", "paradigm", "polychain"]

for vc in vc_accounts:
    new_follows = get_new_following_7d(vc)
    if new_follows:
        print(f"@{vc} started following {len(new_follows)} new crypto accounts this week:")
        for u in new_follows:
            print(f"  @{u['username']} (followed {u.get('followerDate', 'recently')})")
    else:
        print(f"@{vc}: no new crypto follows this week")
    print()
```

### Descubrir proyectos emergentes

Una puntuación creciente indica que cuentas influyentes están prestando atención:

```python theme={null}
watchlist = ["new_project_1", "new_project_2", "new_project_3", "new_project_4"]

rising = []
for handle in watchlist:
    try:
        score = get_score(handle)
        changes = get_score_changes(handle)
        if changes["week_delta"] > 5:
            rising.append({
                "handle": handle,
                "score": score,
                "week_delta": changes["week_delta"],
            })
    except Exception:
        continue

rising.sort(key=lambda x: x["week_delta"], reverse=True)

print("Rising projects (Score gained this week):")
for r in rising:
    print(f"  @{r['handle']}: Score {r['score']} ({r['week_delta']:+} this week)")
```

***

## Exportar a CSV

```python theme={null}
import csv
import time

def export_crypto_analysis(handles, output_file="crypto_analysis.csv"):
    """Export Score and follower stats for a list of accounts."""
    fields = ["username", "score", "week_delta", "month_delta",
              "crypto_followers", "influencers", "projects", "vcs"]

    with open(output_file, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()

        for handle in handles:
            try:
                score = get_score(handle)
                changes = get_score_changes(handle)
                stats = get_follower_breakdown(handle)

                writer.writerow({
                    "username": handle,
                    "score": score,
                    "week_delta": changes["week_delta"],
                    "month_delta": changes["month_delta"],
                    "crypto_followers": stats["followers_count"],
                    "influencers": stats["influencers_count"],
                    "projects": stats["projects_count"],
                    "vcs": stats["venture_capitals_count"],
                })
            except Exception as e:
                print(f"Error for @{handle}: {e}")

            time.sleep(0.15)  # 3 API calls per account

    print(f"Exported {len(handles)} accounts to {output_file}")
```

***

## Próximos pasos

* [Análisis de competidores](https://docs.sorsa.io/es/Competitor-Analysis): combina puntuación, perfiles y contenido.
* [Seguidores y cuentas seguidas](https://docs.sorsa.io/es/followers-and-following): obtén la lista completa, incluidas cuentas ajenas al sector.
* [Descubrimiento del público objetivo](https://docs.sorsa.io/es/target-audiences-Discovery): comunidades y búsquedas de biografías.
* [Verificación de campañas](https://docs.sorsa.io/es/Marketing-Campaign-Verification): acciones de campañas de criptomonedas.
* [Referencia de la API](https://docs.sorsa.io/es/api-reference-guide): especificaciones de análisis de criptomonedas.