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

# Empezando con R y v2 de la X API

> Tutorial para llamar al endpoint user lookup de la X API v2 desde R usando httr y jsonlite, incluyendo la configuración del bearer token y el parseo de respuestas JSON en R.

## Introducción

Este tutorial te guiará por lo que necesitas para empezar con el lenguaje de programación
R y la X API v2. Usando R para conectarse al
endpoint [user lookup](/x-api/users/lookup/introduction), mostraré cómo trabajar
con el JSON devuelto por la X API. User lookup es un método GET y devuelve
información sobre un usuario o grupo de usuarios, especificados por un user ID o un
username.

Si no lo conoces, R es uno de los lenguajes más populares para tareas comunes de Ciencia de
Datos como análisis de series temporales, modelado, visualización y otros análisis
de datos, y se utiliza con frecuencia junto con la X API. Con el endpoint
user lookup, puedes usar el
[user object](/x-api/fundamentals/data-dictionary/reference#user) para
determinar una correlación entre el número de seguidores que tiene una persona y la
puntuación de sentimiento de su bio. El user object también puede usarse para mapear un grupo de
cuentas basándose en la ubicación listada públicamente en sus perfiles.

### Empezando con la X API

Antes de poder usar la X API v2, necesitarás
[registrarte](https://developer.x.com/en/portal/petition/essential/basic-info)
para obtener una cuenta de desarrollador.

Una vez que tengas una cuenta de desarrollador aprobada, primero deberás crear un
[Project](/resources/fundamentals/developer-apps). Los Projects te permiten organizar tu trabajo
según cómo pienses usar la X API, para que puedas gestionar de forma efectiva
tu acceso a la API y monitorizar tu uso.

Cada Project contiene una [App](/resources/fundamentals/developer-apps), con la cual puedes
generar las credenciales necesarias para usar la X API. Puedes aprender más
sobre cómo empezar con la X API en la sección
[getting started](/x-api/getting-started/about-x-api) de nuestra
documentación.

### Configurar tu entorno de R

Primero, necesitas [descargar R](https://cloud.r-project.org/), lo que puedes hacer
en el [sitio web de cran.](https://cran.r-project.org/)

Después, para configurar un entorno para trabajar con R, puedes usar
[R studio](https://www.rstudio.com/), el R extension pack para
[Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=Ikuyadeu.r-pack),
o un
[cuaderno de Jupyter](https://docs.anaconda.com/anaconda/navigator/tutorials/r-lang/)
si vienes del mundo de Python.

### Configurar tu variable de entorno

Para los ejemplos de código que voy a mostrar hoy, te conviene crear una
variable de entorno para tu bearer token. El Bearer Token es lo que te permite
autenticarte en la X API y comenzar a hacer solicitudes. Primero, reemplaza
"your-bearer-token" con tu propio bearer token, que puede obtenerse en la sección
de claves y tokens de tu App en la Developer Console. Necesitarás ejecutar
esta línea de código en la consola antes de empezar a escribir un script.

```r theme={null}
Sys.setenv(BEARER_TOKEN = "your-bearer-token")
```

### Hacer tu solicitud

Puedes usar el paquete
[httr](https://cran.r-project.org/web/packages/httr/index.html) para hacer solicitudes HTTP
a la X API. Si aún no lo has instalado,
instala el paquete en tu consola. También necesitarás instalar
[jsonlite](https://cran.r-project.org/web/packages/jsonlite/index.html) para trabajar
con nuestro objeto JSON y [dplyr](https://dplyr.tidyverse.org/) para la manipulación
de datos.

```r theme={null}
install.packages("httr")
install.packages("jsonlite")
install.packages("dplyr")
```

Ahora puedes empezar a escribir tu script de R para conectarte a la API. En la parte superior del
archivo, llama a los paquetes httr, jsonlite y dplyr.

```r theme={null}
require(httr)
require(jsonlite)
require(dplyr)
```

El primer paso en tu ejemplo de código es prepararte para autenticarte en la
X API. Toma el
[Bearer Token](/resources/fundamentals/authentication#using-and-generating-an-app-only-bearer-token) que sacaste de
tu App y pásalo en tus headers para la autenticación. En el
ejemplo siguiente, reemplaza \$BEARER\_TOKEN con tu token.

```r theme={null}
bearer_token <- Sys.getenv("$BEARER_TOKEN")
headers <- c(`Authorization` = sprintf('Bearer %s', bearer_token))
```

Una vez que tengas configurada tu autenticación, define los parámetros de tu solicitud.
Por defecto, obtendrás el id, name y username de cada usuario que recibas.
Puedes ajustar este payload añadiendo
[fields](/x-api/fundamentals/fields) y
[expansions](/x-api/fundamentals/expansions) adicionales. Para este ejemplo, querrás
la bio del perfil del usuario, que se solicita usando user.fields=description,
y una expansion que contenga el pinned Post del usuario.

```r theme={null}
params <- list(`user.fields` = 'description', `expansions` = 'pinned_tweet_id')
```

Ahora estás listo para formatear tu URL con el handle de X, también conocido como
account, del que quieres obtener más información. Usa el método readline
para permitir que esta muestra sea reutilizable. Después de escribir el handle que quieres
consultar, formatea tu URL para que contenga el handle que definas reemplazando \$USERNAME con
el handle de X deseado.

```r theme={null}
handle <- readline('$USERNAME')
url_handle <- sprintf('https://api.x.com/2/users/by?usernames=%s', handle)
```

En este punto, usa el paquete httr para hacer una solicitud GET a la URL que acabas
de crear, pasa nuestras credenciales de autenticación por el header y pasa los
parámetros que definiste. Puedes guardar la respuesta como un objeto de texto en la
variable obj e imprimirla para ver el resultado de la solicitud que hiciste.

```r theme={null}
response <-
  httr::GET(url = url_handle,
    httr::add_headers(.headers = headers),
    query = params)
obj <- httr::content(response, as = "text")
print(obj)
```

### Trabajar con nuestro payload JSON

Una de mis formas favoritas de trabajar con un JSON es usar un data frame, que te permite
acceder fácilmente a datos anidados complejos. Para hacerlo, usa el método fromJSON del
paquete jsonlite para aplanar tu archivo y que los campos estén en el mismo
objeto. Luego, pasa ese objeto a un data frame. Ahora estás listo para ver este
data frame.

```
json_data <- fromJSON(obj, flatten = TRUE) %>% as.data.frame View(json_data)
```

Puedes acceder a los campos de los datos desde el data frame y pasarlos a una
cadena que contenga el handle, el username y la bio.

```r theme={null}
final <-
  sprintf(
    "Handle: %s\nBio: %s\nPinned Post: %s",
    json_data$data.username,
    json_data$data.description,
    json_data$includes.tweets.text
  )
```

Usa cat en lugar de print para ver el objeto con saltos de línea entre cada campo que
estés extrayendo.

```r theme={null}
cat(final)
```

Si tuvieras varios handles para los que hiciste solicitudes, podrías usar fácilmente un bucle
para acceder a cada elemento del data frame.

### Conclusión

Espero que este tutorial pueda ser un punto de partida para trabajar con R y la X
API. Como siguiente paso, quizá quieras revisar nuestras muestras en R para recent search,
Post lookup y user lookup en nuestro
[código de ejemplo de v2](https://github.com/xdevplatform). Asegúrate de contárnoslo en los
[foros](https://devcommunity.x.com/) si tienes algún problema por el
camino o publica en [@XDevelopers](https://x.com/XDevelopers) si este
tutorial te inspira a crear algo.