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

# Introducción a R y a la versión 2 de la X API

<div id="introduction">
  ## Introducción
</div>

Este tutorial explicará lo que necesitas para comenzar a trabajar con el
lenguaje de programación R y la X API v2. Usando R para conectarte al endpoint
[user lookup](/es/x-api/users/lookup/introduction), te 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 un grupo de usuarios, especificados por un user ID o un
username.

Si no estás familiarizado, 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 tipos de análisis de datos, y a menudo se usa junto con la
X API. Con el endpoint de user lookup, puedes usar el
[user object](/es/x-api/fundamentals/data-dictionary#user) para
determinar una correlación entre la cantidad de seguidores que tiene una persona y la
puntuación de sentimiento de su biografía. El user object también puede usarse para mapear un grupo de
cuentas según la ubicación que aparece públicamente en sus perfiles.

<div id="getting-started-with-the-x-api">
  ### Primeros pasos con la X API
</div>

Antes de poder usar la X API v2, necesitas
[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](/es/resources/fundamentals/developer-apps). Los Projects te permiten organizar tu trabajo
según cómo tengas previsto usar la X API, de modo que puedas gestionar eficazmente
tu acceso a la API y supervisar su uso.

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

<div id="getting-your-r-environment-set-up">
  ### Configurar tu entorno de R
</div>

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

Luego, para configurar un entorno de trabajo con R, puedes usar
[RStudio](https://www.rstudio.com/), el paquete de extensión de R para
[Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=Ikuyadeu.r-pack),
o un
[Jupyter notebook](https://docs.anaconda.com/anaconda/navigator/tutorials/r-lang/)
si vienes del mundo de Python.

<div id="setting-up-your-environment-variable">
  ### Configuración de tu variable de entorno
</div>

Para los ejemplos de código que voy a mostrar hoy, querrás 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 realizar solicitudes. Primero, reemplaza
“your-bearer-token” con tu propio Bearer Token, que puedes obtener en la
sección de claves y tokens de tu App en la Consola de desarrollador. Tendrás que ejecutar
esta línea de código en la consola antes de empezar a escribir un script.

```r theme={null}
Sys.setenv(BEARER_TOKEN = "tu-token-de-portador")
```

<div id="making-your-request">
  ### Realizar tu solicitud
</div>

Puedes usar el paquete
[httr](https://cran.r-project.org/web/packages/httr/index.html) para realizar
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 comenzar a escribir tu script de R para conectarte a la API. En la parte superior del
archivo, carga 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 con la
X API. Toma el
[Bearer Token](/es/resources/fundamentals/authentication#using-and-generating-an-app-only-bearer-token) que obtuviste de
tu App y inclúyelo en tus encabezados para la autenticación. En el siguiente
ejemplo, 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.
De forma predeterminada, recibirás el id, el nombre y el nombre de usuario de cada usuario que obtengas
como respuesta. Puedes hacer ajustes a esta carga JSON agregando
[fields](/es/x-api/fundamentals/fields) y
[expansions](/es/x-api/fundamentals/expansions). En este ejemplo, necesitarás
la biografía del perfil del usuario, que se solicita usando user.fields=description,
y una expansión que contenga la Publicación fijada del usuario.

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

Ahora estás listo para formatear la URL con el handle de X, también conocido como
cuenta, sobre la cual quieres obtener más información. Usa el método readline
para que este ejemplo se pueda reutilizar. Después de escribir el handle que quieras consultar,
formatea la URL para que contenga el handle que definiste 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, utiliza el paquete httr para hacer una solicitud GET a la URL que
acabaste de crear, pasa nuestra credencial de autenticación mediante el encabezado
y pasa los parámetros que definiste. Puedes guardar la respuesta como un objeto
de texto en la variable obj e imprimirlo para ver el resultado de la solicitud
que realizaste.

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

<div id="working-with-our-json-payload">
  ### Trabajar con nuestro payload JSON
</div>

Una de mis formas favoritas de trabajar con JSON es usar un data frame, lo que te permite acceder fácilmente a datos complejos y anidados. Para hacerlo, utiliza el método fromJSON del paquete jsonlite para aplanar el archivo y que los campos queden en un mismo objeto. Luego, pasa ese objeto a un data frame. Ahora ya puedes visualizar este data frame.

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

Puedes acceder a los campos de los datos del data frame y pasarlos a una
cadena de texto que incluya el handle, el nombre de usuario y la biografía.

```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 visualizar el objeto con saltos de línea entre cada campo que estás recuperando.

```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.

<div id="conclusion">
  ### Conclusión
</div>

Esperamos que este tutorial pueda ser un punto de partida para trabajar con R y la
API de X. Como siguiente paso, quizá quieras consultar nuestros ejemplos en R para búsquedas recientes,
consulta de Publicaciones y consulta de usuarios en nuestro
[código de ejemplo de la v2](https://github.com/xdevplatform). Asegúrate de avisarnos en los
[foros](https://devcommunity.x.com/) si encuentras algún problema durante el
proceso o haz una Publicación mencionando a [@XDevelopers](https://x.com/XDevelopers) si este
tutorial te inspira a crear algo.