Ce workflow n8n permet de scraper automatiquement des articles tendances à partir de mots-clés spécifiques et de les stocker dans un tableur Feishu pour une analyse rapide. En entrant un terme de recherche, le système récupère les publications les plus lues et les organise de manière structurée.

Prérequis techniques

Configuration de l'environnement n8n

Assurez-vous d'avoir une instance n8n opérationnelle, que ce soit en local ou via une solution hébergée.

Installation du module Feishu

Dans l'interface de n8n, accédez aux paramètres, puis à la section des nœuds communautaires. Recherchez et installez le package n8n-nodes-feishu-lite.

Création d'une application Feishu

Connectez-vous au portail des développeurs Feishu pour créer une application d'entreprise. Configurez les permissions nécessaires pour les opérations sur les tableurs multidimensionnels et notez les identifiants d'application générés.

Préparation du tableur Feishu

Créez un nouveau tableur multidimensionnel dans Feishu. Récupérez son token d'accès et son identifiant unique, puis liez l'application précédemment créée en lui accordant des droits d'édition.

Architecture du workflow

Le processus suit une séquence logique : réception d'un mot-clé, appel à une API externe pour extraire des données d'articles, transformation des résultats pour correspondre au format du tableur Feishu, et enfin insertion automatisée des enregistrements.

Détail des nœuds

1. Déclencheur manuel

Ce nœud initialise le workflow lors d'une action utilisateur. Aucune configuration spécifique n'est requise.

2. Définition des variables

Ajoutez un nœur de type "Edit Fields" avec les paramètres suivents : un mot-clé cible, le nombre de pages à parcourir, une clé d'accès à l'API de données, ainsi que les identifiants du tableur Feishu.

3. Génération dynamique des requêtes

Un nœur Code JavaScript prépare les appels API en fonction du volume de données souhaité. Voici une implémentation modifiée :

// Récupération du paramètre de pagination
const totalPages = $input.first().json['nombre_pages'];

// Construction d'un tableau d'objets pour les itérations
const iterationArray = [];
for (let currentIndex = 1; currentIndex <= totalPages; currentIndex++) {
  iterationArray.push({
    pageIndex: currentIndex
  });
}

return iterationArray;

4. Boucle de traitement

Le nœur "Loop Over Items" permet d'itérer sur chaque élément du tableau généré précédemmment. Ce composant est essentiel pour le traitement séquentiel des requêtes.

5. Appel API pour la récupération des données

Configurez un nœur HTTP Request avec la méthode POST vers l'endpoint de l'API. Les en-têtes doivent inclure le type de contenu JSON, et le corps de la requête doit dynamiquement référencer les variables de mot-clé et de pagination :

{
  "keyword": "{{ $('Set').item.json['mot_cle'] }}",
  "order": 1,
  "search_scope": 3,
  "time_range": 7,
  "page_number": {{ $('Loop Over Items').item.json.pageIndex }},
  "api_token": "{{ $('Set').item.json['cle_api'] }}"
}

6. Transformation des données

Un second nœur Code restructure les résultats bruts de l'API pour les adapter au schéma du tableur Feishu. La fonction de nettoyage et la logique de mappage ont été réécrites :

// Fonction d'échappement des caractères spéciaux
function sanitizeTextField(input) {
  if (typeof input !== 'string' || input === null) {
    return input;
  }
  return input.replace(/\\/g, '\\\\')
              .replace(/"/g, '\\"')
              .replace(/\n/g, '\\n')
              .replace(/\r/g, '\\r')
              .replace(/\t/g, '\\t');
}

// Extraction et formatage des articles
const rawData = $input.first().json.data;
const structuredRecords = [];

for (const record of rawData) {
  const cleanRecord = {
    "titre_article": sanitizeTextField(record.title),
    "lien_publication": sanitizeTextField(record.url),
    "contenu_textuel": sanitizeTextField(record.content),
    "date_publication": sanitizeTextField(record.publish_time_str),
    "nom_compte": sanitizeTextField(record.wx_name),
    "categorie_theme": sanitizeTextField(record.classify),
    "nombre_vues": Number(record.read) || 0,
    "nombre_mentions_jaime": Number(record.praise) || 0,
    "nombre_partages": Number(record.looking) || 0
  };
  structuredRecords.push(cleanRecord);
}

return structuredRecords;

7. Insertoin dans Feishu

Le nœur Feishu finalise le processus en insérant les données formatées dans le tableur spécifié. Le corps de la requête utilise les champs transformés :

{
  "fields": {
    "titre_article": "{{ $json.titre_article }}",
    "lien_publication": "{{ $json.lien_publication }}",
    "contenu_textuel": "{{ $json.contenu_textuel }}",
    "date_publication": "{{ $json.date_publication }}",
    "nombre_vues": {{ $json.nombre_vues }},
    "nombre_mentions_jaime": {{ $json.nombre_mentions_jaime }},
    "nombre_partages": {{ $json.nombre_partages }},
    "categorie_theme": "{{ $json.categorie_theme }}",
    "nom_compte": "{{ $json.nom_compte }}"
  }
}

8. Bouclage du workflow

Reliez la sortie du nœur Feishu à l'entrée du nœur de boucle pour permettre le traitement complet de toutes les pages définies.

Après exécution, le tableur Feishu contiendra l'ensemble des articles récupérés, prêts pour l'analyse comparative ou la recherche de tendances.