Si on souhaite connaître le nombre de followers d'un compte Twitter, on peut se rendre sur le site officiel de Twitter et afficher la page du compte. On pourrait aussi créer un petit programme pour récupérer ces informations automatiquement en utilisant l'API que propose Twitter. C'est ce qu'on va faire.

On va créer une application qui va récupérer le nombre de followers d'un compte et le nom des personnes qui suivent ce compte. Comme d'habitude, on va utiliser les technologies de Web, JavaScript et NodeJS, pour nous permettre éventuellement d'inclure les résultats dans une page Web.

Regarder la vidéo sur YouTube

Si vous ne pouvez pas regarder la vidéo, un compte rendu est proposé plus bas.

Fonctionnement d'une API

Pour récupérer les informations dont on a besoin, on va utiliser l'API officielle de Twitter. Une API est ce qu'on appelle une interface, c'est-à-dire un système sur lequel on peut se connecter pour récupérer des informations.

Pour comprendre le fonctionnement de l'API, on peut consulter la documentation qui est en ligne à cette adresse : developer.twitter.com

Cette documentation explique notamment que Twitter propose deux versions de l'API : la version 1.1 et la version 2. Nous allons utiliser exclusivement la v2. La version est entièrement fonctionnelle et propose notamment la possibilité de récupérer les informations d'un compte, dont le nombre de followers.

La doc explique aussi que l'API est RESTful, ce qui veut dire que l'API utilise les méthodes classiques du Web :

  • GET pour récupérer une information ;
  • POST pour créer une nouvelle information ;
  • PUT pour modifier une information existante ;
  • DELETE pour supprimer une information.

La méthode GET est aussi utilisée par les navigateurs pour afficher les pages Internet.

Plusieurs fonctionnalitée sont proposées par l'API. Celle qui nous intéresse est User Lookup, qui nous permet de récupérer les informations d'un compte.

Les informations d'un compte peuvent être récupérées à partir de l'identifiant du compte ou du nom d'utilisateur, c'est-à-dire le nom qui commence par @.

En réponse, l'API retourne un objet de type User. L'objet peut contenir plusieurs propriétés, notamment :

  • L'identifiant du compte : id ;
  • Le nom de l'utilisateur : name ;
  • Le nom du compte : surname ;
  • Le nombre de followers : public_metrics ;
  • etc.

Deux possibilités sont proposées pour récupérer les informations d'un compte :

  • soit par l'identifiant : GET /2/users/:id (docs)
  • soit par le nom d'utilisateur : GET /2/users/by/username/:username (docs)

Il faut, bien sûr, remplacer :id par l'identifiant du compte et :username par le nom du compte recherché. Étant donné qu'on ne possède pas encore l'identifiant des comptes, on va utiliser la seconde option.

Pour effectuer une requête et récupérer les informations du compte à partir d'un compte, il faut fournir une clé d'authentification appelée Bearer Token. Cette clé est fournie lorsqu'on crée un compte pour développeur sur Twitter. Pour créer un compte développeur, il faut créer un compte Twitter classique, puis faire une demande d'accès à l'API. Ensuite, un projet peut être créé dans lequel un token est communiqué.

Un dernier point avant de passer au code. La documentation indique qu'il est possible de préciser les propriétés qu'on souhaite obtenir en réponse en passant le paramètre user.fields avec pour valeur une liste de propriétés séparée par une virgule.

Développer l'application connectée à l'API Twitter

On peut commencer à écrire notre programme et envoyer notre première requête à l'API.

Pour nous faciliter la tâche, on va utiliser le module node-fetch qui permet de créer facilement des requêtes, de la même manière que la fonction fetch dans le navigateur.

Pour initialiser le projet et installer le module node-fetch depuis le gestionnaire de paquets npm :

npm init -y
npm install node-fetch

On peut ensuite utiliser le module pour créer notre programme :

// Chargement du module "node-fetch"
const fetch = require('node-fetch')

// Déclaration de la classe TwitterAPI
class TwitterAPI {
  // Constructeur appelé lorsque la classe est instanciée
  constructor(token) {
    // Sauvegarde le token fourni en paramètre à l'intérieur de la classe
    // pour pouvoir le réutiliser dans les autres fonctions de la classe.
    this.token = token
  }

  // Fonction permettant d'envoyer des requêtes à l'API de Twitter
  // Paramètres attendus :
  // - le nom de la route, par ex : /users/by/username/Morgan_Schmiedt
  // - un objet avec les paramètres.
  async requeteAPI(url, parameters) {
    const params = new URLSearchParams(parameters)
    const urlParams = params.toString()

    // Envoi la requête avec le token d'authentification
    // .. et converti le contenu de la réponse au format JSON.
    const body = await fetch(`https://api.twitter.com/2${url}?${urlParams}`, {
      headers: {
        Authorization: `Bearer ${this.token}`,
      },
    }).then(res => res.json())

    return body
  }

  // Fonction permettant de récupérer les informations d'un compte
  // à partir d'un nom de compte passé en paramètre.
  // Les propritétés retournies sont précisées dans le paramètre 'user.fields'
  async getUserByUsername(compteTwitter) {
    return this.requeteAPI(`/users/by/username/${compteTwitter}`, {
      'user.fields': [
        'id',
        'name',
        'username',
        'public_metrics',
      ].join(','),
    })
  }

  // Fonction permettant de récupérer les followers d'un compte
  // à partir d'un identifiant de compte.
  // Les propritétés retournies sont précisées dans le paramètre 'user.fields'
  async getFollowersById(compteId) {
    return this.requeteAPI(`/users/${compteId}/followers`, {
      'user.fields': [
        'id',
        'name',
        'username',
        'description',
        'public_metrics',
        'profile_image_url',
      ].join(','),
    })
  }
}

// Fonction déclarée et exécutée immédiatement (IIFE)
;(async() => {
  // Le nom du compte à recherche est passé en paramètre de la commande
  const compteTwitter = process.argv[2]

  if (compteTwitter == null) {
    console.log('Le nom du compte doit être indiqué en paramètre.')
    return
  }

  // Créer une variable de type "TwitterAPI"
  const API = new TwitterAPI('VOTRE_TOKEN_A_REMPLACER_ICI')

  // Envoie une requête d'informations du compte
  const compte = await API.getUserByUsername(compteTwitter)

  // Récupère l'identifiant du compte à partir de la réponse
  const compteId = compte.data.id

  // Envoie une requête pour obtenir les followers
  const followers = await API.getFollowersById(compteId)

  // Affiche les résultat
  console.log(`Compte Twitter : @${compteTwitter}`)
  console.log(`${compte.data.public_metrics.followers_count} followers`)
  console.log('5 premiers followers :')
  console.log(followers.data
    .slice(0, 5)
    .map(user => `- @${user.username}: ${user.description}`)
    .join('\n'))
})()

Le programme peut être exécuté à partir de la ligne de commande, en indiquant le nom du compte recherché en paramètre, par exemple : node index.js Morgan_Schmiedt

Une logique similaire peut être utilisée pour afficher le nombre de followers sur une page Web. Gardez cependant à l'esprit que :

  • Le token est comme un mot de passe et ne doit pas être connu du public. La logique ne peut donc pas être intégrée dans la partie front-end du site.
  • Une requête de ce type ne peut pas être réalisée à chaque fois qu'un visiteur consulte votre page, car le chargement de la page serait plus lent et surtout parce que Twitter impose des limitations : 900 requêtes par 15 minutes dans le cas d'une demande d'informations d'un compte. Le résultat de la requête doit donc être mis en cache d'une façon ou d'une autre.