De nombre de usuario de Twitter a ID de usuario por API

#Qué es un ID de usuario de Twitter y cómo encontrarlo

Un ID de usuario de Twitter es el número permanente que X asigna a una cuenta en el momento en que se crea. El nombre de usuario después de la @ es una etiqueta de 1 a 15 letras, dígitos o _ que su dueño puede cambiar en cualquier momento, y cuando queda libre, cualquiera puede reclamarlo. El ID nunca cambia ni pasa a otra cuenta, y por eso las apps, las exportaciones y las bases de datos apuntan a las cuentas por ID. Los desarrolladores también lo llaman ID de cuenta, ID numérico o UID.

Para una sola cuenta, el Buscador de IDs de Twitter gratuito muestra el ID detrás de cualquier nombre de usuario o enlace de perfil, y convierte un ID de vuelta en el nombre de usuario actual de la cuenta. No requiere registro.

Las primeras cuentas recibieron IDs cortos: el @jack de Jack Dorsey es 12. Las cuentas abiertas en los últimos años tienen IDs de 18 o 19 dígitos. X no imprime el número en ningún lugar de su app, pero tu propio ID está en el archivo de tus datos: solicítalo en Configuración y privacidad, Tu cuenta, Descargar un archivo de tus datos, luego abre data/account.js y lee accountId.

Un ID de usuario no es un ID de post. El número largo después de /status/ en un enlace de post identifica al post, y el Convertidor de ID de tweet a fecha lee la fecha que lleva dentro. Si envías un ID de post a una consulta de usuario, no encuentra ninguna cuenta.

#Convierte un nombre de usuario en un ID de usuario con Sorsa API

Sorsa API, una API y scraper de Twitter (X) para datos públicos, tiene un endpoint para cada dirección, y cada conversión es una solicitud: desde $1.40 por cada 1,000 conversiones. Cada llamada lleva tu clave en el encabezado ApiKey y devuelve el ID como una cadena JSON, para que no se pierda ningún dígito en el camino.

1. Obtén una clave. Regístrate y copia tu clave de API desde el panel. Incluye 100 solicitudes gratis y no pide tarjeta.

2. Envía el nombre de usuario. Pásalo sin la @ a GET /username-to-id (se abre en una pestaña nueva).

   curl "https://api.sorsa.io/v3/username-to-id/harborline_analytics" \
     -H "ApiKey: YOUR_API_KEY"
   

   {
     "id": "1427632236659332516"
   }
   

3. Ve en el otro sentido cuando lo necesites. GET /id-to-username (se abre en una pestaña nueva) devuelve el nombre de usuario actual de la cuenta en un campo llamado handle, y GET /link-to-id (se abre en una pestaña nueva) recibe un enlace de perfil completo de x.com o twitter.com.

4. Envuelve las tres llamadas. Las mismas conversiones en Python y Node.js:

   import requests
   
   BASE = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def username_to_id(username):
       r = requests.get(f"{BASE}/username-to-id/{username.lstrip('@')}",
                        headers=HEADERS, timeout=30)
       r.raise_for_status()
       return r.json()["id"]          # a string: keep it one
   
   
   def id_to_username(user_id):
       r = requests.get(f"{BASE}/id-to-username/{user_id}",
                        headers=HEADERS, timeout=30)
       r.raise_for_status()
       return r.json()["handle"]      # today's username, without the @
   
   
   def link_to_id(link):
       r = requests.get(f"{BASE}/link-to-id", headers=HEADERS,
                        params={"link": link}, timeout=30)
       r.raise_for_status()
       return r.json()["id"]
   
   
   print(username_to_id("harborline_analytics"))  # 1427632236659332516
   

   const BASE = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY" };
   
   async function get(path) {
     const res = await fetch(BASE + path, { headers });
     if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
     return res.json(); // IDs arrive as strings, so nothing is rounded
   }
   
   const usernameToId = async (name) =>
     (await get(`/username-to-id/${encodeURIComponent(name)}`)).id;
   const idToUsername = async (id) =>
     (await get(`/id-to-username/${id}`)).handle;
   const linkToId = async (link) =>
     (await get(`/link-to-id?link=${encodeURIComponent(link)}`)).id;
   
   console.log(await usernameToId("harborline_analytics"));
   

Un 404 significa que ninguna cuenta pública tiene ese nombre de usuario o ID: se escribió mal, cambió de nombre, fue suspendida o eliminada. Un 401 significa que la clave es incorrecta, un 403 que falta o se quedó sin solicitudes, y un 429 que enviaste más de 20 solicitudes en un segundo. Las solicitudes fallidas nunca se cobran. Cuando necesites también el perfil, GET /info (se abre en una pestaña nueva) devuelve el ID con el perfil completo en la misma solicitud.

#Convierte una lista: 100 nombres de usuario por solicitud

Para una lista, olvida los endpoints de uno en uno: GET /info-batch (se abre en una pestaña nueva) acepta hasta 100 nombres de usuario por solicitud y devuelve el perfil de cada cuenta con su id. Una lista de 10K nombres de usuario toma 100 solicitudes, cuesta desde $0.14 y termina en unos 5 segundos a 20 solicitudes por segundo. Para convertir nombres de usuario de Twitter a IDs de forma masiva, usa el GET /info-batch de Sorsa API: 100 por solicitud, desde $0.014 por cada 1,000, frente a $10.00 por cada 1,000 en la API oficial de X.

Repite el parámetro usernames una vez por cada nombre:

curl -G "https://api.sorsa.io/v3/info-batch" \
  -H "ApiKey: YOUR_API_KEY" \
  --data-urlencode "usernames=harborline_analytics" \
  --data-urlencode "usernames=quietfield_records" \
  --data-urlencode "usernames=copperkettle_maps"

{
  "users": [
    {
      "id": "1427632236659332516",
      "username": "harborline_analytics",
      "display_name": "Harborline Analytics",
      "created_at": "2021-08-17T14:03:44Z",
      "followers_count": 3912,
      "protected": false
    },
    {
      "id": "1612371430079911386",
      "username": "quietfield_records",
      "display_name": "Quietfield Records",
      "created_at": "2023-01-09T08:51:20Z",
      "followers_count": 18406,
      "protected": false
    },
    {
      "id": "1804185541935281502",
      "username": "copperkettle_maps",
      "display_name": "Copperkettle Maps",
      "created_at": "2024-06-21T16:12:08Z",
      "followers_count": 671,
      "protected": false
    }
  ]
}

La respuesta lista solo las cuentas que encontró. Un nombre de usuario que no coincide con ninguna cuenta pública se omite, así que cruza los resultados por nombre de usuario, nunca por posición, y compara en minúsculas: X trata Harborline_Analytics y harborline_analytics como el mismo nombre.

El script de abajo lee accounts.csv con una columna username, descarta duplicados y arrobas sueltas, y escribe accounts_with_ids.csv. Diez hilos comparten un regulador que mantiene la clave a 20 solicitudes por segundo, así que una lista de 1M de nombres de usuario se procesa en unos 8 minutos.

import csv
import threading
import time
from concurrent.futures import ThreadPoolExecutor

import requests

URL = "https://api.sorsa.io/v3/info-batch"
HEADERS = {"ApiKey": "YOUR_API_KEY"}
PER_SECOND = 20                           # the limit on every plan
lock, next_slot = threading.Lock(), [0.0]


def wait_turn():
    """Space requests 1/20 of a second apart across all threads."""
    with lock:
        now = time.monotonic()
        slot = max(now, next_slot[0])
        next_slot[0] = slot + 1 / PER_SECOND
    time.sleep(slot - now)


def fetch(params):
    for _ in range(3):
        wait_turn()
        r = requests.get(URL, headers=HEADERS, params=params, timeout=30)
        if r.status_code != 429:          # 429: over 20 requests a second
            r.raise_for_status()
            return r.json().get("users", [])
        time.sleep(1)
    r.raise_for_status()


def usernames_to_ids(usernames):
    """Map each username (lowercase) to its user ID, 100 per request."""
    names = list(dict.fromkeys(u.strip().lstrip("@").lower()
                               for u in usernames if u.strip()))
    chunks = [names[i:i + 100] for i in range(0, len(names), 100)]
    found = {}
    with ThreadPoolExecutor(max_workers=10) as pool:
        for users in pool.map(lambda c: fetch({"usernames": c}), chunks):
            for user in users:
                found[user["username"].lower()] = user["id"]
    missing = [n for n in names if n not in found]
    return found, missing


with open("accounts.csv", newline="", encoding="utf-8") as f:
    rows = [row["username"] for row in csv.DictReader(f)]

ids, missing = usernames_to_ids(rows)

with open("accounts_with_ids.csv", "w", newline="", encoding="utf-8") as f:
    out = csv.writer(f)
    out.writerow(["username", "user_id"])
    for name, user_id in ids.items():
        out.writerow([name, user_id])     # the ID stays a string

print(len(ids), "converted;", len(missing), "not found:", missing[:10])

Para reintentos, cursores y solicitudes asíncronas más allá de este script, la guía de la API de Twitter en Python tiene patrones que funcionan. Las listas de seguidores no necesitan ninguna conversión: la API de seguidores de Twitter devuelve 200 seguidores por página, cada uno con su id ya incluido.

#Convierte IDs de usuario de vuelta en nombres de usuario y detecta cambios de nombre

El mismo endpoint funciona al revés: envía hasta 100 IDs guardados como user_ids, y cada perfil vuelve con el nombre de usuario que usa hoy. Compáralo con el nombre de usuario que guardaste: una diferencia es un cambio de nombre, y un ID que no vuelve pertenece a una cuenta suspendida o eliminada.

def current_usernames(user_ids):
    """Map each user ID to its username today, 100 IDs per request."""
    now = {}
    for i in range(0, len(user_ids), 100):
        for user in fetch({"user_ids": user_ids[i:i + 100]}):
            now[user["id"]] = user["username"]
    return now


stored = {"1427632236659332516": "harborline_analytics",
          "1612371430079911386": "quietfield_records"}
today = current_usernames(list(stored))
for user_id, old in stored.items():
    new = today.get(user_id)
    if new is None:
        print(user_id, "is gone: suspended or deleted")
    elif new.lower() != old.lower():
        print(user_id, "renamed from", old, "to", new)

Ejecútalo con un calendario sobre las cuentas que sigues, y un competidor o creador que cambió de nombre nunca se pierde de tus datos. Los participantes de sorteos y quests funcionan igual: guarda a cada participante por ID, y la API de verificación de Twitter verifica sus follows y reposts con ese ID incluso después de un cambio de nombre.

Para una sola cuenta, GET /about (se abre en una pestaña nueva) agrega username_change_count y last_username_change_at: cuántas veces cambió su nombre de usuario y cuándo lo hizo por última vez. El Verificador del historial de nombres de usuario de Twitter gratuito lee ambos datos sin código. Los nombres de usuario anteriores en sí no son públicos, porque X no los publica.

Para llevar a una persona a una cuenta que puede cambiar de nombre, enlaza a x.com/i/user/ seguido del ID: X abre el perfil con su nombre de usuario actual. El enlace x.com/i/user/12 lleva a @jack.

#Limpia las entradas mixtas antes de convertir

Las listas reales mezclan formatos: nombres de usuario con y sin la @, enlaces de x.com y twitter.com con parámetros de seguimiento, enlaces móviles, enlaces /i/user/ y números sueltos. Clasifica cada valor antes de llamar a nada, para que los IDs se salten la consulta y la basura nunca cueste una solicitud.

Cada formato común se lee como nombre de usuario, ID de usuario o nada:

• jack, con o sin la @

  Se interpreta como

  Nombre de usuario

• https://twitter.com/jack?s=20

  Se interpreta como

  Nombre de usuario

• https://mobile.twitter.com/jack

  Se interpreta como

  Nombre de usuario

• https://x.com/jack/status/20

  Se interpreta como

  Nombre de usuario del autor del post cuando se copió el enlace

• https://x.com/i/user/12

  Se interpreta como

  ID de usuario

• https://twitter.com/intent/user?user_id=12

  Se interpreta como

  ID de usuario

• 12 o 1427632236659332516

  Se interpreta como

  ID de usuario

• https://x.com/home, un hashtag, un correo

  Se interpreta como

  No es una cuenta

import re

USERNAME = re.compile(r"^[A-Za-z0-9_]{1,15}$")   # X's own pattern
RESERVED = {"home", "explore", "search", "i", "intent", "settings",
            "messages", "notifications", "hashtag", "share", "compose"}
LINK = re.compile(r"^(?:https?://)?(?:www\.|mobile\.)?"
                  r"(?:x|twitter)\.com/([^?#]+)", re.I)


def classify(value):
    """Return ("id", ...), ("username", ...) or ("bad", value)."""
    v = value.strip()
    if v.isdigit():                          # digits alone: an ID
        return ("id", v) if len(v) <= 19 else ("bad", value)
    q = re.search(r"[?&]user_id=(\d{1,19})\b", v)
    if q:                                    # .../intent/user?user_id=
        return ("id", q.group(1))
    m = LINK.match(v)
    if m:
        parts = m.group(1).strip("/").split("/")
        if parts[:2] == ["i", "user"]:       # x.com/i/user/<ID>
            ok = len(parts) > 2 and parts[2].isdigit()
            return ("id", parts[2]) if ok else ("bad", value)
        v = parts[0]                         # a profile or a post link
    v = v.lstrip("@")
    if USERNAME.match(v) and v.lower() not in RESERVED:
        return ("username", v.lower())
    return ("bad", value)

La referencia de la API (se abre en una pestaña nueva) de X da el patrón del nombre de usuario como 1 a 15 letras, dígitos o _, y el patrón admite solo dígitos. Así que un número suelto podría ser tanto un nombre de usuario como un ID. La función interpreta los dígitos sueltos como un ID y los dígitos con una @ delante como un nombre de usuario: conserva la @ en tu entrada cuando te refieras a un nombre. Los nombres de usuario de demostración que aparecen en el resto de esta página superan los 15 caracteres a propósito, para que ninguno pueda pertenecer a una cuenta real.

El nombre de usuario dentro de un enlace de post es el nombre del autor el día en que se copió el enlace. Si la cuenta cambió de nombre desde entonces, ese nombre no encuentra nada, o encuentra a otra persona que lo reclamó. Cuando un conjunto de datos contiene enlaces de posts, consulta los posts y toma el ID de cada autor de los datos del post: ningún cambio de nombre lo altera.

#Guarda el ID como cadena, nunca como número

Mantén todo ID de Twitter como cadena desde la respuesta de la API hasta la base de datos. Un ID de 19 dígitos es mayor que el entero más grande que un número de JavaScript o una celda de hoja de cálculo guarda con exactitud, así que un tipo numérico cambia en silencio sus últimos dígitos, y el ID cambiado no apunta a ninguna cuenta.

• JavaScript. Number.MAX_SAFE_INTEGER es 9007199254740991, 16 dígitos. La propia guía de IDs (se abre en una pestaña nueva) de X les dice a los desarrolladores que usen siempre IDs como cadenas por este motivo. Si interpretas un ID sin comillas, 1427632236659332516 se convierte en 1427632236659332600.
• Excel. Excel guarda los números con 15 dígitos de precisión y muestra los grandes en notación científica, así que el mismo ID se abre como 1.42763E+18 y se guarda como 1427632236659330000 (Soporte de Microsoft (se abre en una pestaña nueva)). Importa el CSV desde Datos, Desde texto/CSV y configura la columna del ID como Texto antes de cargar.
• pandas. Lee el archivo con dtype={"user_id": str}, o la columna también se convierte en números.
• Bases de datos. X recomienda BIGINT o TEXT en PostgreSQL, BIGINT UNSIGNED o VARCHAR(20) en MySQL, una cadena en MongoDB y TEXT en SQLite. Un INT de 32 bits se desborda a partir de 2147483647.

Pega cualquier ID abajo para ver qué le hace cada uno de estos.

La misma regla vale para las exportaciones. Cuando exportes seguidores de Twitter o cualquier lista de cuentas a CSV, abre el archivo con la columna del ID configurada como Texto, o los IDs que guardaste dejan de coincidir con los de la API.

Para tener en cuenta

Sorsa API devuelve todo ID como una cadena JSON: IDs de usuario, IDs de post y los IDs dentro de listas como pinned_tweet_ids. Los dígitos solo cambian cuando tu propio código u hoja de cálculo los convierte en números, así que la solución siempre está del lado de la lectura.

#Cuánto cuesta convertir nombres de usuario y cuánto tarda

Convertir nombres de usuario a IDs cuesta $10.00 por cada 1,000 en la API oficial de X y desde $0.014 por cada 1,000 en Sorsa API. X cobra cada usuario que devuelve una consulta (se abre en una pestaña nueva) a $0.010, ya sea que la llamada lleve un nombre de usuario o 100. Sorsa API cobra la solicitud, y una solicitud GET /info-batch lleva 100 nombres de usuario.

El tiempo es la otra brecha. Los límites de solicitudes (se abre en una pestaña nueva) de X permiten a una app hacer 300 consultas de usuarios cada 15 minutos, así que 1M de nombres de usuario toman unas 8 horas 20 minutos incluso a 100 por llamada. Sorsa API funciona a 20 solicitudes por segundo en todos los planes y convierte la misma lista en unos 8 minutos 20 segundos.

En cada criterio del que depende este trabajo, Sorsa API sale mejor que la API oficial de X:

• Precio por cada 1,000 nombres de usuario

  Sorsa API

  desde $0.014

  API oficial de X

  $10.00

• Tiempo para 1M de nombres de usuario

  Sorsa API

  unos 8 minutos

  API oficial de X

  unas 8 horas 20 minutos

• Configuración

  Sorsa API

  una clave de API en un encabezado

  API oficial de X

  cuenta de desarrollador, app, bearer token

• De IDs a nombres de usuario

  Sorsa API

  el mismo endpoint, el mismo precio

  API oficial de X

  $0.010 por usuario

• Tu inicio de sesión de X

  Sorsa API

  nunca se pide

  API oficial de X

  la cuenta de desarrollador queda en tu cuenta de X

La lista de precios completa de la API oficial de X, con posts y seguidores incluidos, está en nuestra guía de precios de la API de X.

#Convierte tu primera lista

Sorsa API convierte nombres de usuario de Twitter en IDs de usuario a 100 por solicitud, desde $0.014 por cada 1,000, y convierte los IDs guardados de vuelta en los nombres de usuario de hoy al mismo precio. Es una API de Twitter sin cuenta de desarrollador: una clave en un encabezado, sin OAuth y sin revisión de la app. Tus 100 solicitudes gratis convierten los primeros 10K nombres de usuario, así que pega el script por lotes de arriba, agrega tu clave y ejecútalo con tu lista.

#Preguntas frecuentes