Comment Automatiser sa Newsletter avec un Agent IA

Table des matières

Mis à jour juin 2026.

TL;DR : Un agent Claude lit ma file d’attente de contenu, choisit l’angle le plus fort de la semaine, rédige une newsletter dans ma voix, segmente la liste par niveau d’engagement et programme l’envoi via l’API Kit — tout ça sans que j’ouvre un éditeur. Je consulte un aperçu rendu et j’appuie sur approuver. Le travail créatif difficile est à moi ; l’exécution mécanique appartient à l’agent.

[Lecture de l’opérateur] Une newsletter qui s’envoie régulièrement surpasse celle qui est “meilleure” mais qui sort quand l’inspiration frappe. La contrainte était la surcharge d’exécution, pas les idées. J’avais des idées ; je n’avais pas la bande passante pour les formater, planifier et segmenter chaque semaine. L’agent a éliminé cet écart.

Le vrai goulot d’étranglement dans la plupart des workflows de newsletter

La plupart des conseils d’automatisation de newsletter se concentrent sur la mauvaise chose : les séquences de bienvenue, les automatisations, la logique de tags. C’est bien, mais ça ne résout pas le problème de création semaine après semaine.

Le vrai frein est celui-ci : vous savez ce que vous voulez dire, mais s’asseoir pour le formater, écrire les variantes d’objet, choisir le bon segment et le programmer au bon moment coûte 2-3 heures de changement de contexte par semaine. Multipliez par 52 semaines et vous aurez passé une semaine entière de travail juste à envoyer des newsletters.

L’agent gère chaque étape après “je sais quel est l’angle de cette semaine.”

Le stack que j’utilise

• Kit (anciennement ConvertKit) — la plateforme email. Excellente API, solide tagging d’abonnés, analytique propre. L’API compatible avec les agents est ce qui m’a convaincu.
• Claude (Anthropic SDK) — la couche de génération
• Cloudflare Workers — déclencheur planifié (s’exécute chaque mardi à 8h CT)
• Airtable — file d’attente de contenu et boîte d’approbation

Si vous n’êtes pas sur Kit, le même modèle fonctionne avec n’importe quelle plateforme disposant d’une API REST pour créer et planifier des diffusions.

Étape 1 : La file d’attente de contenu

L’agent a besoin d’une source de vérité sur “de quoi écrivons-nous.” La mienne est un tableau Airtable avec des colonnes :

• Topic — l’angle ou la question
• Status — Queue / Approved / Sent
• Tier — si c’est pour tous les abonnés ou seulement les plus engagés
• Notes — toutes les contraintes (éviter ce ton, inclure ce lien, etc.)

Chaque semaine, je passe 10 minutes à ajouter 2-3 sujets à la file. C’est ma contribution créative. Le reste est le travail de l’agent.

Étape 2 : L’agent de rédaction

// workers/newsletter-agent/index.ts
import Anthropic from "@anthropic-ai/sdk";
import Airtable from "airtable";

const client = new Anthropic();

const VOICE_SYSTEM = `You are writing a weekly newsletter for Alejandro Rioja's subscribers.
His audience: founders and operators interested in AI agents, SEO, and growing a one-person business.
Voice: direct, first-person, practitioner. No hype, no "exciting times," no excessive bullet lists.
Structure every newsletter as:
1. One-sentence hook (the problem or observation)
2. The core insight (3–5 paragraphs, no headers, conversational)
3. One concrete action the reader can take this week
4. A short sign-off (2 sentences max)
Subject line: specific, outcome-oriented, under 50 chars. No clickbait.
Return JSON: { "subject": "...", "preheader": "...", "body": "..." }`;

async function getNextTopic(): Promise<{ id: string; topic: string; notes: string; tier: string }> {
  const base = new Airtable({ apiKey: process.env.AIRTABLE_API_KEY }).base(process.env.AIRTABLE_BASE_ID!);
  const records = await base("Newsletter Queue")
    .select({ filterByFormula: "{Status} = 'Queue'", sort: [{ field: "Created", direction: "asc" }], maxRecords: 1 })
    .firstPage();
  if (!records.length) throw new Error("Queue is empty. Add topics.");
  const r = records[0];
  return { id: r.id, topic: r.get("Topic") as string, notes: (r.get("Notes") as string) ?? "", tier: (r.get("Tier") as string) ?? "all" };
}

async function draftNewsletter(topic: string, notes: string): Promise<{ subject: string; preheader: string; body: string }> {
  const msg = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    system: VOICE_SYSTEM,
    messages: [{ role: "user", content: `Write this week's newsletter on: "${topic}". Additional notes: ${notes || "none"}` }],
  });
  const text = (msg.content[0] as any).text.replace(/```json\n?/, "").replace(/```/, "").trim();
  return JSON.parse(text);
}

async function scheduleWithKit(draft: { subject: string; preheader: string; body: string }, tier: string): Promise<string> {
  const segmentId = tier === "engaged" ? process.env.KIT_ENGAGED_SEGMENT_ID : null;
  const sendAt = new Date();
  sendAt.setDate(sendAt.getDate() + ((4 - sendAt.getDay() + 7) % 7)); // next Thursday
  sendAt.setHours(9, 0, 0, 0); // 9am CT

  const payload: any = {
    broadcast: {
      subject: draft.subject,
      content: draft.body,
      description: draft.preheader,
      send_at: sendAt.toISOString(),
      email_layout_template: "minimal",
    },
  };
  if (segmentId) payload.broadcast.segment_id = segmentId;

  const res = await fetch("https://api.kit.com/v4/broadcasts", {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-Kit-Api-Key": process.env.KIT_API_KEY! },
    body: JSON.stringify(payload),
  });
  const data = await res.json();
  return data.broadcast?.id ?? "";
}

export default {
  async scheduled(_event: ScheduledEvent, env: Env) {
    // Inject env vars
    Object.assign(process.env, env);
    const { id, topic, notes, tier } = await getNextTopic();
    const draft = await draftNewsletter(topic, notes);
    const broadcastId = await scheduleWithKit(draft, tier);

    // Mark as Approved in Airtable (not Sent — human reviews the Kit preview before confirm)
    const base = new Airtable({ apiKey: env.AIRTABLE_API_KEY }).base(env.AIRTABLE_BASE_ID);
    await base("Newsletter Queue").update(id, { Status: "Approved", KitBroadcastId: broadcastId });

    console.log(`Scheduled broadcast ${broadcastId} for topic: ${topic}`);
  },
};

Étape 3 : L’étape d’approbation

L’agent crée la diffusion à l’état de brouillon dans Kit et marque l’enregistrement Airtable comme “Approved.” Kit m’envoie une notification avec un lien d’aperçu. Je clique dessus, je le lis, et si ça me semble correct, je confirme l’envoi. Si je veux des modifications, j’édite directement dans Kit.

C’est la porte qui empêche l’agent d’être entièrement autonome sur les emails sortants. Je fais confiance aux brouillons environ 90% du temps. Les 10% que je détecte en révision — un ton légèrement décalé, une statistique à vérifier, un lien à ajouter — valent les 3 minutes de révision.

Ce que l’agent gère et que je ne veux plus jamais faire

• Écrire les variantes de ligne d’objet et choisir la meilleure
• Formater le texte du préen-tête
• Calculer le bon moment d’envoi (mon audience ouvre le jeudi matin ; l’agent le sait)
• Segmenter correctement selon le niveau du sujet
• Tout consigner dans Airtable pour avoir un historique

Ce qui m’appartient encore

L’idée. Le sujet dans la file est le mien. L’angle est le mien. L’agent est un excellent exécuteur d’un brief clair ; ce n’est pas une couche stratégique. Si je mets un mauvais sujet dans la file, j’obtiens une newsletter bien rédigée sur un mauvais sujet.

Aussi : la porte de première révision. Chaque envoi passe sous mes yeux avant de partir. Ça ne va pas changer.

La conclusion de l’opérateur

Si vous passez plus d’une heure par semaine sur les mécaniques de newsletter — formatage, planification, segmentation — vous devriez l’automatiser. L’API Kit est propre, le déclencheur cron du Worker est solide comme un roc, et la qualité des brouillons Claude est suffisamment élevée pour que j’approuve ~90% des premiers brouillons sans modification. Construisez la file dans Airtable, connectez le Worker, et reprenez la création d’idées au lieu d’exécuter des envois.