Automatisation de la veille YouTube et LinkedIn avec n8n (Guide pour débutants)

Dans cet article pédagogique, nous allons apprendre à utiliser n8n pour créer un système complet d’automatisation de veille sur YouTube et LinkedIn. Pas de panique si vous débutez : nous adopterons un ton accessible et expliquerons chaque étape. Nous couvrirons deux cas d’usage concrets réunis en un seul workflow cohérent :

Veille YouTube – Récupération automatique des nouvelles vidéos d’une chaîne YouTube via son flux RSS. Nous utiliserons le nœud communautaire YouTube Transcript pour extraire la transcription de chaque nouvelle vidéo, puis un modèle d’IA pour générer un résumé (avec un agent IA local comme Oyama ou via l’API OpenAI). Enfin, nous stockerons les résumés dans une base de données PostgreSQL.
Veille LinkedIn – Surveillance des publications LinkedIn d’un influenceur via PhantomBuster. Nous extrairons les derniers posts du profil, produirons un résumé de chaque post (avec le modèle local Oyama), puis les enregistrerons dans PostgreSQL. Ensuite, nous ajouterons une étape finale qui utilise OpenAI pour générer un résumé global des idées principales à partir des données en base.

Suivez le guide ! Nous commencerons par préparer l’environnement (installation de n8n, activation des nodes communautaires, ajout de Puppeteer, configuration de PostgreSQL et d’Oyama), puis nous détaillerons chaque workflow. Des captures d’écran de l’interface n8n illustrent les étapes clés pour vous guider visuellement.

Installation de n8n via Docker et activation des Community Nodes

Pour démarrer, installons n8n en utilisant Docker. Cela permet une installation propre et reproductible. Si Docker est déjà installé sur votre machine, exécutez par exemple la commande suivante (elle télécharge l’image n8n officielle et lance un conteneur) :

docker run -d --name n8n -p 5678:5678 -v ~/.n8n:/home/node/.n8n n8nio/n8n:latest

Cette commande lance n8n en arrière-plan (-d), lie l’interface web au port 5678 de votre machine, et monte un volume local (~/.n8n) pour persister les données (ainsi, vos workflows ne seront pas perdus au redémarrage du conteneur).

Activation des nœuds communautaires : Par défaut, la version self-hosted de n8n permet l’installation de nœuds communautaires (Community Nodes). Vérifiez que l’option est bien activée. Si besoin, vous pouvez forcer l’activation via une variable d’environnement Docker N8N_COMMUNITY_PACKAGES_ENABLED=true (c’est normalement le cas par défaut). Avec cette option, un nouveau menu “Community Nodes” apparaîtra dans l’interface n8n, vous permettant d’installer des nœuds supplémentaires développés par la communauté.

Installation de n8n avec Docker Compose : Si vous préférez Docker Compose, créez un fichier docker-compose.yml incluant un service pour n8n. N’oubliez pas d’y indiquer les variables d’environnement nécessaires (par exemple pour activer les Community Nodes). Voici un extrait minimal :

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_COMMUNITY_PACKAGES_ENABLED=true
      # ... (autres variables si besoin)
    volumes:
      - ~/.n8n:/home/node/.n8n

Une fois votre compose prêt, lancez docker-compose up -d pour démarrer n8n.

Ajout de Puppeteer pour le nœud YouTube Transcript

Le premier cas d’usage (transcription YouTube) nécessite un composant supplémentaire : Puppeteer. En effet, le nœud communautaire YouTube Transcript utilise Puppeteer (un navigateur headless automatisé) pour récupérer le texte des vidéos. Pour que ce nœud fonctionne, il faut que Puppeteer soit installé et opérationnel dans l’environnement n8n.

Pourquoi Puppeteer ? La récupération des sous-titres YouTube sans API officielle implique de scraper le site YouTube via un navigateur invisible (headless). Puppeteer permet cela en contrôlant un Chrome/Chromium en tâche de fond. Le nœud YouTube Transcript en a besoin pour lancer un navigateur et extraire la transcription via l’interface web (c’est plus fiable que l’API YouTube qui, elle, ne donne les captions que pour vos propres vidéos).

Installation de Puppeteer dans le conteneur n8n : Il existe deux approches possibles. La première consiste à installer Puppeteer “à chaud” dans le conteneur en cours d’exécution, la seconde est de construire une image Docker personnalisée incluant Puppeteer. Pour rester simple, détaillons la deuxième méthode (image custom), mais sachez que la première méthode est possible via docker exec.

Créer un Dockerfile custom pour n8n : Dans un répertoire, créez un fichier Dockerfile avec le contenu suivant : FROM n8nio/n8n:latest USER root # Installer Chromium + dépendances Puppeteer RUN apk add --no-cache udev chromium harfbuzz "freetype@edge" "nss@edge" \ && npm install -g puppeteer USER node Explication : on part de l’image n8n officielle, on passe en root pour installer des paquets. On ajoute Chromium (navigateur headless) et quelques librairies nécessaires (fonts, etc.), puis on installe Puppeteer via npm. La variable PUPPETEER_SKIP_CHROMIUM_DOWNLOAD est ici optionnelle car nous installons nous-mêmes Chromium. (Note: l’image n8n est basée sur Alpine Linux, d’où l’utilisation de apk.)
Construire l’image : exécutez docker build -t n8n-puppeteer . dans le dossier contenant le Dockerfile. Docker télécharge tout ce qu’il faut et crée une image locale nommée n8n-puppeteer.
Lancer n8n avec l’image custom : utilisez docker run (ou compose) en spécifiant image: n8n-puppeteer. Par exemple : docker run -d --name n8n -p 5678:5678 -v ~/.n8n:/home/node/.n8n n8n-puppeteer Cette instance de n8n inclut désormais Puppeteer et un Chrome headless prêt à l’emploi.

💡 Astuce : si vous avez déjà un conteneur n8n en route et préférez ne pas reconstruire d’image, vous pouvez installer Puppeteer à la volée. Faites : docker exec -it -u root n8n apk add ... chromium... && npm install -g puppeteer comme indiqué dans la documentation du node. N’oubliez pas de définir PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium-browser dans l’environnement du conteneur pour que Puppeteer utilise le bon binaire.

Installation du nœud communautaire YouTube Transcript

Maintenant que Puppeteer est en place, installons le nœud YouTube Transcript. Depuis l’interface n8n (http://localhost:5678), rendez-vous dans le menu Community Nodes. Recherchez “youtube-transcript” – vous devriez trouver le paquet n8n-nodes-youtube-transcript. Cliquez sur Installer. (Si on vous demande d’autoriser les nœuds non vérifiés, acceptez – ce paquet peut être non vérifié au moment de l’écriture.) Une fois installé, n8n redémarre pour charger le nouveau nœud.

Exemple d’écran de configuration d’un PhantomBuster pour LinkedIn. Ici, le phantom LinkedIn Activity Extractor est configuré pour extraire les posts d’un profil donné. Nous utiliserons ce Phantom via n8n pour récupérer automatiquement les publications LinkedIn.

Lorsque n8n revient en ligne, vous trouverez dans la liste des nœuds disponibles un nouveau nœud YouTube Transcript 🎉. Nous sommes prêts à construire notre workflow de veille !

(NB: À ce stade, notre environnement n8n est équipé pour les tâches à venir. Pour récapituler, nous avons : n8n tournant dans Docker, les Community Nodes activés, Puppeteer installé, et le node YouTube Transcript disponible.)

Configuration de PostgreSQL et PGAdmin

Avant de plonger dans les workflows, configurons la base de données qui stockera nos résumés. Nous utiliserons PostgreSQL, un SGBD open-source robuste, pour conserver les informations extraites (résumés de vidéos et de posts). Si vous n’avez pas déjà PostgreSQL d’installé, le plus simple est de le lancer aussi via Docker.

Lancer un conteneur PostgreSQL : Exécutez par exemple :

docker run -d --name postgres -e POSTGRES_PASSWORD=mysecretpassword -p 5432:5432 postgres:15

Cela déploie PostgreSQL version 15, avec le mot de passe mysecretpassword pour l’utilisateur par défaut postgres, et expose le port 5432. Bien sûr, adaptez le mot de passe et autres paramètres selon vos besoins (vous pouvez aussi créer un utilisateur/db spécifique).

PGAdmin (optionnel) : Pour gérer visuellement la base, vous pouvez utiliser PGAdmin, l’interface web officielle de PostgreSQL. Un moyen rapide :

docker run -d --name pgadmin -e PGADMIN_DEFAULT_EMAIL=user@domain.com -e PGADMIN_DEFAULT_PASSWORD=admin -p 8080:80 dpage/pgadmin4

Accédez-y sur http://localhost:8080, connectez-vous avec user@domain.com/admin, puis ajoutez un nouveau serveur pointant sur votre conteneur postgres (host : host.docker.internal sur Windows/Mac ou l’IP du conteneur sur Linux, port 5432, user : postgres, mot de passe celui défini). Vous pourrez ainsi visualiser les tables, lancer des requêtes, etc.

Création des tables : Pour notre usage, nous pouvons créer deux tables : videosummaries pour les résumés YouTube et linkedin_posts pour les posts LinkedIn. Par exemple, via PGAdmin ou psql :

CREATE TABLE videosummaries (
    video_id TEXT PRIMARY KEY,
    title TEXT,
    summary TEXT,
    published_at TIMESTAMP
);
CREATE TABLE linkedin_posts (
    post_id TEXT PRIMARY KEY,
    author TEXT,
    content TEXT,
    summary TEXT,
    posted_at TIMESTAMP
);

Ces schémas simples stockent un identifiant unique (l’ID de la vidéo YouTube ou du post LinkedIn) en clé primaire, le titre ou contenu original, le résumé généré, et une date. On pourra enrichir selon les besoins (par ex, URL de la vidéo, lien du post, etc.).

💡 Bonnes pratiques PostgreSQL :

Clés primaires uniques : En utilisant les IDs naturels des contenus comme clé, on évite les doublons. Ainsi, si un workflow tente d’insérer un résumé déjà existant, on aura soit une erreur (qu’il faudra gérer) soit on choisira de mettre à jour l’enregistrement existant.
Requêtes paramétrées ou nœud dédié : n8n propose un nœud Postgres permettant d’insérer, mettre à jour ou requêter sans écrire du SQL brut. Vous pouvez l’utiliser en configurant un Credentials PostgreSQL (hôte, user, mdp, base).
Vérifier avant insertion : Il est souvent utile de vérifier si la donnée existe déjà (par exemple via un SELECT) avant d’insérer, ou d’utiliser une requête INSERT ... ON CONFLICT ... UPDATE en SQL. Nous montrerons comment gérer cela dans le workflow.

Enfin, ajoutez dans n8n un Credential de type Postgres pour que n8n puisse se connecter à la base. Indiquez l’hôte (probablement host.docker.internal si n8n est en Docker et Postgres sur l’hôte ou un autre conteneur du même compose), le port 5432, l’utilisateur (postgres), le mot de passe et la base (postgres par défaut).

Utilisation d’un modèle d’IA local (Oyama) vs OpenAI

Pour la génération de résumés, nous avons deux options : utiliser un modèle d’IA local ou faire appel à l’API OpenAI dans le cloud. L’option locale offre plus de confidentialité (et pas de coût par requête), tandis que l’API OpenAI peut être plus simple à configurer si vous avez une clé API.

Oyama (modèle IA local) : Oyama est un agent IA local basé sur Ollama, permettant de faire tourner des modèles de langage open-source chez vous. Supposons que vous ayez un modèle local prêt (par ex. un conteneur LocalAI ou Ollama en cours d’exécution sur votre machine, qui expose une API compatible OpenAI). Dans ce cas, n8n peut y accéder.

Exemple de configuration : Si n8n tourne en Docker et votre serveur AI local écoute sur le port 8000 de votre machine, vous pouvez configurer n8n pour utiliser ce point de terminaison au lieu de api.openai.com. Dans les credentials OpenAI de n8n, il suffit de spécifier l’URL de base de l’API locale. Par exemple, on peut définir la variable d’environnement OPENAI_API_BASE_URL=http://host.docker.internal:8000/v1 (où host.docker.internal permet au conteneur Docker d’atteindre l’hôte). Ainsi, les appels du nœud OpenAI seront redirigés vers votre modèle local. Un utilisateur témoigne par exemple avoir utilisé l’URL http://host.docker.internal:1234/v1 dans la config OpenAI de n8n pour se connecter à LM Studio local, en mettant une clé factice.
Vérification : Assurez-vous que votre service local accepte les appels au format OpenAI. Beaucoup de solutions (Ollama, LocalAI, text-gen-webui API…) exposent des endpoints /v1/completions ou /v1/chat/completions. Testez hors n8n avec curl pour confirmer la communication. Vous pourriez avoir besoin d’autoriser le conteneur à contacter l’hôte (sur Linux, peut-être utiliser --add-host=host.docker.internal:host-gateway lors du run Docker, bien que l’IP fixe 172.17.0.1 fonctionne aussi).

OpenAI (cloud) : Si vous optez pour l’API OpenAI officielle, créez une clé API sur OpenAI dashboard. Ajoutez un credential OpenAI dans n8n avec cette clé. Vous pourrez alors utiliser le nœud OpenAI ou OpenAI Chat en choisissant un modèle (par ex GPT-3.5-turbo) pour générer les résumés.

Dans la suite, pour simplicité, nous utiliserons majoritairement l’API OpenAI cloud dans les exemples de nœuds (c’est plus direct pour un débutant). Sachez toutefois que vous pouvez remplacer ces nœuds par des appels à votre modèle local Oyama en configurant comme expliqué ci-dessus.

Cas d’usage 1 : Veille YouTube automatisée

Passons à la pratique avec le premier workflow. L’objectif : surveiller une chaîne YouTube et obtenir automatiquement le résumé des nouvelles vidéos publiées. Ce workflow s’exécutera régulièrement (par exemple tous les jours) et suivra ces étapes :

Lecture du flux RSS YouTube de la chaîne pour lister les nouvelles vidéos.
Extraction de la transcription de chaque nouvelle vidéo, via le nœud YouTube Transcript.
Génération d’un résumé de la transcription, à l’aide d’un modèle IA (OpenAI ou local).
Enregistrement du résumé dans PostgreSQL, en évitant les doublons.
Répéter pour chaque vidéo récente non encore traitée.

Voici à quoi ressemble le workflow complet dans n8n :

Capture d’écran d’un workflow n8n (illustratif) combinant plusieurs nœuds pour automatiser un processus. Dans notre cas, un flux RSS est lu, puis les données sont transformées et envoyées vers OpenAI et PostgreSQL. Le schéma général sera similaire, avec des nœuds pour RSS → Transcript → IA → PostgreSQL.

1. Flux RSS d’une chaîne YouTube

YouTube fournit un flux RSS pour chaque chaîne. Il suffit de connaître l’ID de la chaîne ou son handle. Par exemple, le flux d’une chaîne s’obtient via l’URL :

https://www.youtube.com/feeds/videos.xml?channel_id=<ID_DE_LA_CHaINE>

ou si la chaîne a un nom d’utilisateur personnalisé :

https://www.youtube.com/feeds/videos.xml?user=<NOM_UTILISATEUR>

Trouvez l’ID de la chaîne en question (vous pouvez l’extraire de l’URL de la chaîne YouTube). Dans n8n, ajoutez un nœud RSS Read. Configurez-le ainsi :

URL : l’adresse du flux RSS de la chaîne.
Options : vous pouvez limiter le nombre d’items retournés ou filtrer par date, mais par défaut il prendra les dernières vidéos.

Exemple : pour la chaîne n8n (handle @n8n), l’ID est UCJlkBMeKq33ujmnZsEnZMJQ et le flux est https://www.youtube.com/feeds/videos.xml?channel_id=UCJlkBMeKq33ujmnZsEnZMJQ. En sortie, le nœud RSS Read fournira une liste d’items (chaque item représentant une vidéo, avec titre, lien, date, etc.).

2. Filtrer les nouvelles vidéos

Le flux RSS contient généralement les dernières vidéos, même celles déjà vues précédemment. Pour éviter de retraiter des vidéos anciennes, on va filtrer les items pour ne garder que celles publiées depuis notre dernière exécution. Plusieurs approches :

Utiliser un nœud IF ou Filter sur la date de publication (champ pubDate de l’item) par rapport à la date actuelle moins X temps.
Ou bien comparer la liste des IDs de vidéos avec celles déjà en base de données.

Pour simplicité, supposons qu’on exécute le workflow assez fréquemment et qu’on traite toutes les vidéos du flux mais qu’on empêche les doublons en base. Ainsi, même si on revoit une vidéo ancienne, la tentative d’insertion en DB échouera (car l’ID existe) ou sera ignorée via un UPSERT. Nous reviendrons sur ce point en étape 4.

3. Extraction de la transcription YouTube

Pour chaque vidéo à traiter, on a besoin de son ID YouTube (le flux RSS fournit généralement le lien complet de la vidéo). On peut extraire l’ID à l’aide d’un nœud Function (code) ou Set avec une expression. Par exemple, si le lien est https://www.youtube.com/watch?v=XyzAbc123, l’ID est la portion après ?v=. Un petit code JavaScript dans un nœud Function peut faire ça :

const url = item.json.link;              // lien de la vidéo
const idMatch = url.match(/v=([^&]+)/);
item.json.videoId = idMatch ? idMatch[1] : url;
return item;

Ce code ajoute un champ videoId contenant l’identifiant pur. (Il est aussi possible que le flux RSS contienne directement un champ yt:videoId – vérifiez la structure dans RSS Read).

On enchaîne ensuite avec le nœud YouTube Transcript. Déposez-le dans le workflow et connectez-le. Dans ses propriétés, entrez le Video ID soit en dur pour un test, soit via une expression qui pointe vers $json["videoId"] provenant du nœud précédent. Ce nœud va alors lancer Puppeteer en arrière-plan pour ouvrir la page YouTube et récupérer la transcription complète de la vidéo (en général la transcription auto-générée ou fournie, en anglais ou langue originale).

Note: Le nœud YouTube Transcript retourne le texte complet des sous-titres de la vidéo, généralement sous forme d’un champ transcript. Selon la longueur de la vidéo, cela peut être volumineux (plusieurs milliers de caractères).

4. Génération d’un résumé avec l’IA

Nous voici avec la transcription brute de la vidéo. Il s’agit souvent d’un texte assez long, qu’il faut synthétiser. C’est là qu’intervient l’IA. Nous allons utiliser un nœud OpenAI (ou OpenAI Chat) pour produire un résumé concis.

Ajoutez un nœud OpenAI et connectez-le après le transcript. Sélectionnez vos credentials OpenAI (configurés plus tôt avec la clé API, ou pointant vers Oyama en local). Choisissez l’opération “Chat Completion” (pour utiliser un modèle type GPT-3.5 turbo) avec un rôle system qui donnera l’instruction de résumé, et le contenu du transcript en message user. Par exemple :

System message : “Tu es un assistant qui résume des vidéos YouTube. Fournis un résumé court et clair du contenu de la vidéo.”
User message : insérez l’expression {{$json["transcript"]}} pour passer la transcription récupérée.

Si vous utilisez un nœud OpenAI “Completion” classique, vous pouvez simplement fournir un prompt combiné du style : “Résume le texte suivant : {{ $json[« transcript »] }}”. Assurez-vous de bien injecter le texte via les expressions n8n (le petit bouton FX permet d’insérer des variables depuis les nœuds précédents).

Lorsque vous exécuterez ce nœud, l’IA va générer un résumé en français (vous pouvez préciser la langue si besoin dans le prompt). Le résultat apparaîtra typiquement dans un champ completion ou message selon le nœud utilisé. On peut renommer ce champ en summary via un nœud Set par la suite pour uniformiser.

⚠️ Conseil : Surveillez la longueur de la transcription envoyée à OpenAI. La limite de tokens de GPT-3.5 est autour de 4096 tokens. Si vos vidéos sont très longues, envisagez de tronquer ou segmenter le transcript (ou d’utiliser un modèle local plus costaud en contexte). Pour notre cas, on assumera que ça tient.

5. Stockage du résumé dans PostgreSQL

Enfin, nous stockons le résumé généré dans la base de données. Utilisez un nœud Postgres (opération Insert) connecté après l’OpenAI. Sélectionnez le credential PostgreSQL configuré. Renseignez la table cible, par exemple videosummaries. Mappez les colonnes :

video_id = l’ID de la vidéo (depuis $json["videoId"] qu’on a défini plus haut),
title = le titre de la vidéo ($json["title"] provenant du RSS),
summary = le résumé généré ($json["summary"] provenant du nœud OpenAI/Set),
published_at = la date de publication ($json["pubDate"] du RSS, qu’il faudra peut-être convertir en timestamp).

Le nœud va insérer une ligne en base. Si la vidéo était déjà présente, deux cas : soit le nœud Postgres Insert retournera une erreur de contrainte (dans ce cas, on peut cocher “Continue on Fail” pour éviter d’arrêter tout le workflow), soit on peut opter pour une autre stratégie. Bonne pratique : utiliser l’opération Execute Query du nœud Postgres pour faire un UPSERT. Par exemple :

INSERT INTO videosummaries(video_id, title, summary, published_at)
VALUES($1, $2, $3, $4)
ON CONFLICT (video_id) DO UPDATE 
    SET title=EXCLUDED.title, summary=EXCLUDED.summary, published_at=EXCLUDED.published_at;

On passerait alors les 4 valeurs via la propriété Query Parameters. Cela insérera ou mettra à jour en un seul appel. Pour un débutant, cette approche est un peu plus avancée, donc on peut s’en tenir à l’utilisation du nœud Insert simple et à la gestion “continue on error” pour ne pas planter s’il y a doublon.

À ce stade, le workflow YouTube est complet. On peut l’améliorer en ajoutant un nœud de déclenchement planifié (par ex. un nœud Cron configuré chaque jour à 8h) connecté tout au début, de façon à automatiser son exécution quotidienne sans intervention. Activez le workflow dans n8n, et votre veille YouTube fonctionne en autonomie 🎉. Chaque nouvelle vidéo publiée sur la chaîne sera transcrite et résumée dans la foulée.

(Vous pouvez vérifier dans PGAdmin que les nouvelles entrées apparaissent bien dans la table videosummaries après chaque exécution.)

Cas d’usage 2 : Veille LinkedIn automatisée

Abordons maintenant le deuxième cas d’usage : la veille de contenu sur LinkedIn. Imaginons que vous souhaitiez suivre un influenceur ou leader d’opinion qui publie régulièrement sur LinkedIn, et automatiser la récupération de ses posts avec des résumés. Directement, l’API LinkedIn ne permet pas facilement d’extraire les posts d’un utilisateur tiers. C’est là qu’intervient PhantomBuster, un service en ligne spécialisé dans le scraping automatisé de plateformes web (LinkedIn, Twitter, Instagram, etc.) sans avoir à coder de scraper vous-même.

Notre plan de workflow :

Utiliser PhantomBuster pour récupérer les derniers posts d’un profil LinkedIn donné.
Extraire le contenu de chaque post (texte, date, liens…).
Générer un résumé pour chaque post via l’IA locale (Oyama) – ou OpenAI selon config.
Enregistrer chaque résumé de post dans PostgreSQL (linkedin_posts table).
Faire une synthèse globale de l’ensemble des posts récents via OpenAI, à partir des données stockées (par exemple pour dégager les grandes idées de la semaine).

1. Configuration de PhantomBuster pour LinkedIn

Créer un compte PhantomBuster : Rendez-vous sur phantombuster.com et inscrivez-vous (il y a un essai gratuit). Une fois connecté, vous aurez accès à divers Phantoms (scripts préétablis pour différentes tâches). Pour notre besoin, utilisez le Phantom appelé LinkedIn Activity Extractor (ou un similaire) qui extrait les activités récentes d’un profil LinkedIn. Ce Phantom va parcourir la page d’activité publique d’une personne et récupérer les posts qu’elle a publiés (texte des posts, nombre de likes/commentaires, etc.).

Configurer le Phantom : Dans PhantomBuster, créez une instance du LinkedIn Activity Extractor. On vous demandera :

L’URL du profil LinkedIn cible (par ex. https://www.linkedin.com/in/nomutilisateur/).
Votre cookie de session LinkedIn (pour autoriser PhantomBuster à accéder aux données – PhantomBuster fournit un outil pour récupérer automatiquement ce cookie depuis votre navigateur).
D’éventuels autres paramètres (comme le nombre de posts à récupérer, etc.).

Enregistrez/configurez le Phantom. Vous pouvez le tester une fois manuellement sur PhantomBuster pour voir s’il parvient à lister les posts (il génère généralement un fichier JSON ou CSV en résultat, consultable dans l’interface PhantomBuster).

Obtenir l’API Key PhantomBuster : Pour piloter PhantomBuster via n8n, il nous faut une clé API. Sur votre compte PhantomBuster, allez dans Settings > API Key (ou Workspace settings > Third party API keys) et générez une clé si ce n’est pas déjà fait. Copiez cette clé.

Credentials PhantomBuster dans n8n : Dans n8n, ajoutez un credential de type PhantomBuster. Collez la clé API. N8n utilisera cette clé pour s’authentifier auprès de l’API PhantomBuster.

2. Récupération des posts LinkedIn via n8n

Avec le Phantom configuré et la clé API prête, on peut interagir depuis n8n grâce au nœud PhantomBuster (ce nœud fait partie des intégrations natives depuis les dernières versions de n8n).

Ajoutez un nœud PhantomBuster dans le workflow. Paramétrez-le ainsi :

Resource : Agent (car les phantoms sont appelés « agents » dans l’API PB).
Operation : Launch (pour lancer l’agent).
Agent ID : l’identifiant du Phantom LinkedIn Activity Extractor que vous avez configuré.

👉 Comment trouver l’Agent ID ? Dans PhantomBuster, ouvrez votre Phantom. L’URL contient un identifiant numérique unique. Par exemple, https://api.phantombuster.com/agent/123456 (123456 étant l’ID). Vous pouvez aussi utiliser l’opération Get all agents du nœud PhantomBuster pour lister vos phantoms et repérer l’ID correspondant.

Une fois l’ID en place, le nœud PhantomBuster peut lancer l’extraction. Cependant, si votre Phantom requiert un paramètre sessionCookie ou autre que vous n’avez pas enregistré par défaut, il faudra le fournir. Dans notre config, on a normalement déjà stocké le cookie dans PhantomBuster lors de la config initiale, donc pas besoin de le renvoyer à chaque appel. (À noter : s’il fallait passer des arguments dynamiques, on pourrait ajouter des champs supplémentaires dans le nœud n8n, comme l’indique un post de forum).

Exécution et récupération des résultats : Quand on lance l’agent, PhantomBuster va probablement mettre quelques secondes à finir la tâche. Le nœud n8n Launch ajoute l’agent dans la file de lancement. Pour obtenir les données une fois l’agent terminé, on doit appeler l’opération Get output sur cet agent.

On peut soit enchaîner un second nœud PhantomBuster (Resource: Agent, Operation: Get output, en fournissant le même Agent ID). Ce nœud-là récupérera le résultat le plus récent de l’agent, généralement un JSON contenant un tableau des posts. Par exemple, chaque post peut avoir un champ content (texte du post), author, timestamp, etc. L’autre approche est d’utiliser l’option “Wait for completion” si disponible dans le nœud Launch, mais pour clarté on va séparer en deux nœuds.

Reliez donc un second nœud PhantomBuster configuré en Get output juste après le premier.

3. Traitement des données des posts

Le nœud Get output renverra possiblement un objet JSON encapsulé. Il se peut que le tableau des posts soit dans $json["output"] ou un champ du genre. Utilisez le nœud Function ou IF approprié pour isoler le tableau des posts et ensuite splitter chaque post en item séparé (n8n a le nœud Split In Batches ou on peut manipuler via code). Par simplicité, imaginons que Get output nous renvoie déjà plusieurs items (un par post) – si ce n’est pas le cas, un petit Function qui fait return items[0].json.posts; (selon le format exact) suffira à obtenir un item par post.

Nous avons maintenant chaque post LinkedIn comme un item dans n8n, contenant par exemple:

{
  "content": "Texte du post ici...",
  "author": "Nom de l'auteur",
  "timestamp": "2025-06-01T12:34:56.789Z",
  "postUrl": "https://www.linkedin.com/posts/...",
  "id": "linkedin-post-id"
}

Les champs varient selon PhantomBuster, mais l’essentiel est qu’on a le texte du post (content) que l’on souhaite résumer.

Avant de résumer, on peut effectuer quelques transformations:

Peut-être nettoyer le texte (content) pour enlever des emojis ou balises HTML s’il y en a.
On peut aussi concaténer le author et la date au contenu pour donner du contexte à l’IA (mais pas forcément nécessaire pour un simple résumé).
S’assurer que les champs nécessaires pour l’insertion en base (like id, content) sont bien nommés.

On peut utiliser un nœud Set pour renommer ou sélectionner les champs pertinents. Par exemple, renommer id en post_id pour correspondre à notre table, et timestamp en posted_at. On peut aussi limiter la longueur du contenu si c’est très long (mais généralement les posts LinkedIn sont de longueur raisonnable).

4. Résumé de chaque post via modèle local (Oyama)

Pour chaque post (chaque item actuellement dans le workflow), on va générer un résumé. Comme exercice, utilisons ici le modèle local Oyama via un appel API. Supposons qu’on a configuré n8n pour pointer l’OpenAI node vers notre instance locale (ou qu’on utilise un nœud HTTP Request pour interroger une API locale).

Option 1 : nœud OpenAI Chat (base URL locale) – Si vous avez suivi la partie configuration Oyama, vous pouvez réutiliser un nœud OpenAI comme précédemment, avec un prompt de résumé. La seule différence est que cette fois, l’appel ne partira pas vers les serveurs OpenAI mais vers votre machine (grâce au OPENAI_API_BASE_URL redéfini). Vous pouvez donc procéder de la même manière que pour les vidéos : un nœud OpenAI Chat, system prompt “Tu résumes du contenu LinkedIn”, user message avec {{$json["content"]}}.

Option 2 : nœud HTTP Request – Alternativement, on pourrait utiliser un nœud HTTP configuré sur l’URL de l’API locale (par ex. http://oyama:8000/v1/chat/completions) en envoyant un JSON contenant le prompt. Cette méthode est plus technique et dépend de l’API précise de votre modèle. Pour un débutant, rester dans le cadre du nœud OpenAI (avec détournement vers local) est plus simple.

Pour l’explication, continuons à utiliser le nœud OpenAI (disons GPT-3.5) pour sortir un résumé, sachant que vous pouvez basculer vers local plus tard sans changer la logique.

Comme précédemment, le résultat du résumé sera capturé (on le nommera summary).

5. Stockage des posts résumés dans PostgreSQL

On reprend un nœud Postgres (Insert) pour la table linkedin_posts. On y mappe :

post_id = l’ID unique du post (fourni par PhantomBuster, ou on peut utiliser l’URL du post comme identifiant unique).
author = l’auteur du post,
content = le texte original du post (on peut le stocker aussi pour référence),
summary = le résumé généré,
posted_at = la date du post.

Comme pour les vidéos, on veille à éviter les doublons. La clé primaire post_id garantit qu’un même post ne sera pas inséré deux fois. Si le workflow run tous les jours, les posts récents se chevaucheront peut-être, mais l’INSERT échouera sur ceux déjà insérés. Cochez “Continue on Fail” ou implémentez un UPSERT (même technique que précédemment, ON CONFLICT sur post_id DO UPDATE).

A présent, chaque nouveau post détecté est consigné en base avec son résumé. Félicitations, la veille LinkedIn automatisée est en place ! Vous pouvez planifier ce workflow avec un Cron (par ex. toutes les heures ou jours, sachant que PhantomBuster a des limites selon votre plan) pour une surveillance régulière.

(Remarque sécurité : respectez les conditions d’utilisation de LinkedIn. Ne dépassez pas des fréquences trop élevées et ne republiez pas de contenus intégraux. Notre but ici est une veille personnelle.)

6. Résumé global des idées (agrégation)

Dernière étape bonus : produire un résumé global de l’ensemble des posts récupérés, afin d’en extraire les idées principales. Imaginons que l’influenceur a publié 5 posts cette semaine, nous voulons un paragraphe qui synthétise en quoi consistent globalement ses publications récentes.

Pour cela, nous allons interroger la base de données pour récupérer soit les résumés individuels de chaque post, soit directement le texte des posts. Utiliser les résumés déjà générés est plus efficace (moins de volume de texte, et déjà l’essentiel de chaque post).

Ajoutez un nœud Postgres (Select) configuré sur la table linkedin_posts. On peut par exemple sélectionner les posts de la dernière semaine :

SELECT summary FROM linkedin_posts
WHERE posted_at >= NOW() - INTERVAL '7 days';

(en Query ou via l’interface du nœud en filtrant, selon les possibilités). Le nœud retournera plusieurs items (chaque item avec un champ summary contenant le résumé d’un post).

Pour combiner ces résultats en un seul texte, on peut utiliser un nœud Function qui agrège les summaries. Par exemple :

const summaries = items.map(item => item.json.summary);
const combinedText = summaries.join("\n\n");
return [{ json: { combinedText } }];

Ainsi on obtient un seul item avec combinedText qui contient tous les résumés de posts, séparés par deux sauts de ligne.

Enfin, on envoie ce combinedText dans un dernier nœud OpenAI (ou Chat). Le prompt pourrait être : “Voici plusieurs résumés de posts LinkedIn d’un même auteur. Fais un résumé global qui dégage les thèmes et idées principales de l’ensemble.” Et on inclut le texte combiné en entrée. GPT-3.5 ou 4 fera très bien l’affaire pour synthétiser plusieurs paragraphes en un seul.

Le résultat final sera un résumé global de la veille. Vous pouvez par exemple l’envoyer par email ou le poster sur Slack via des nœuds supplémentaires, pour partager la veille avec votre équipe. Ici, on se concentre sur la production de ce résumé final qui clôt le workflow.

(À noter : si vous souhaitiez aussi inclure les vidéos YouTube dans ce résumé global, vous auriez pu interroger également la table videosummaries. Il faudrait alors fusionner les données des deux tables avant de les envoyer à l’IA. C’est une variante possible – par simplicité nous avons résumé globalement que les posts LinkedIn, mais libre à vous d’élargir.)

Conseils pour structurer les données et transformer les items

Au fil de la création de ces workflows, nous avons utilisé plusieurs nœuds de transformation pour manipuler les données entre les étapes. Voici quelques bonnes pratiques et conseils à retenir :

Nœud Set : utile pour renommer des champs, ajouter des champs statiques, ou supprimer ceux qui ne sont pas nécessaires avant une insertion en base. Par exemple, avant d’insérer en DB, on peut ne garder que id, summary, etc., pour avoir une structure propre.
Nœud Function (Code) : permet d’écrire quelques lignes de JavaScript pour des transformations avancées. Nous l’avons utilisé pour extraire un ID d’URL, pour concaténer plusieurs items en un, etc. N8n vous permet d’importer certaines librairies si besoin, mais souvent les méthodes JS de base suffisent (regex, map, join…).
Expressions dans les champs : dans la plupart des nœuds, vous pouvez cliquer sur “Add Expression” et sélectionner des données d’un nœud précédent. Cela évite d’utiliser un nœud intermédiaire. Par exemple, au lieu d’un Function pour extraire videoId comme on l’a fait, on aurait pu mettre directement dans le champ VideoID du nœud YouTube Transcript une expression : {{$json["link"].split("v=")[1]}} (un peu simpliste, mais illustratif). N’hésitez pas à exploiter les expressions pour passer des données à l’IA ou à la DB.
Contrôle du flux avec IF/Switch : Si vous avez besoin de logiques conditionnelles (par ex: si aucun nouveau post, alors ne pas appeler OpenAI), vous pouvez insérer des nœuds IF. Dans notre cas, on a délibérément tenté d’insérer tous les items et laissé le SGDB refuser les doublons, mais on aurait pu faire un IF qui vérifie l’existence dans la DB avant de résumer/inserer. Ce type de contrôle évite des appels IA inutiles sur des données déjà traitées.
Gestion d’erreurs : Activez l’option Continue on Fail sur les nœuds sensibles (par ex, insertion en base) si vous anticipez qu’une erreur non critique peut survenir (duplicate key). Vous pourrez récupérer l’erreur dans le résultat et la traiter ou la logguer, sans interrompre l’exécution globale.

En structurant bien vos données à chaque étape, vous facilitez l’enchaînement du workflow et évitez les surprises. Un bon usage des nœuds de transformation rend le workflow plus robuste et lisible.

Conclusion et extensions possibles

Nous avons construit un système complet de veille automatique : chaque jour, les nouvelles vidéos YouTube d’une chaîne sont transcrites et résumées, les nouveaux posts LinkedIn d’un influenceur sont extraits et synthétisés, et un résumé global des tendances ressort. Tout cela sans intervention manuelle, grâce à n8n et à la puissance des agents IA.

Bien entendu, ce workflow peut être étendu et adapté à d’autres sources et besoins :

💡 Autres plateformes : vous pourriez appliquer une approche similaire à Medium (articles de blog), Twitter (tweets d’un compte – via l’API Twitter ou d’autres outils), Reddit (posts d’un subreddit), etc. Dès qu’une plateforme offre un flux RSS ou qu’un outil comme PhantomBuster peut la scraper, n8n peut s’y connecter.
💡 Notifications : actuellement nous stockons en base et c’est tout. On pourrait ajouter une étape pour envoyer un email quotidien avec les nouveaux résumés, ou les poster sur Slack/Teams. n8n intègre de nombreux connecteurs email et chat pour cela.
💡 Analyse avancée : on pourrait imaginer utiliser les données stockées pour faire de l’analyse de sentiment (par ex via une API d’IA ou un modèle local de classification) sur les posts, ou générer des graphiques (combien de posts par semaine, etc.). PostgreSQL couplé à n8n offre un début de base de données de veille sur laquelle on peut bâtir d’autres automatisations.
💡 Optimisation IA : pour les très longues vidéos, on pourrait intégrer une étape de découpage du transcript en segments et un résumé multi-étapes (résumer chaque partie puis re-synthétiser). De même, pour un grand volume de posts, on pourrait demander à l’IA un classement des sujets les plus abordés, etc.
💡 Autres nœuds communautaires utiles : citons par exemple le nœud HTTP Request (toujours bon à avoir pour appeler n’importe quelle API non gérée nativement), ou des nœuds de parsing (HTML, Markdown) si vous scrapez du contenu brut.

En combinant ces techniques, vous pouvez bâtir votre propre agent de veille automatisée sur mesure. N8n vous sert de glue pour orchestrer le tout, et les possibilités sont infinies. Nous espérons que ce tutoriel vous aura non seulement fait découvrir n8n, mais aussi inspiré pour vos prochains projets d’automatisation, que ce soit pour rester informé des dernières tendances ou pour tout autre workflow mêlant données web et IA.

Bon automatisation ! 🚀