Un responsable marketing chez Qonto a publié sur LinkedIn en mars 2026 qu’il avait remplacé ses 14 prompts Notion disparates par trois scripts Python appelant l’API Claude directement. Résultat : 500 variantes d’annonces Google Ads générées chaque semaine pour 0,60 euro. Pas d’abonnement Make, pas de workflow n8n à maintenir, pas de seat Zapier. Juste un cron et une clé API.
Vous aurez besoin d’un compte Anthropic, de Python 3.10+ et de 30 minutes. Le budget mensuel tourne entre 5 et 28 euros selon le volume, grâce au prompt caching qui réduit le coût des tokens d’entrée répétitifs de 90%.
Pourquoi l’API Claude sans orchestrateur
n8n, Make et Zapier résolvent un vrai problème : connecter des services sans coder. Mais pour les workflows LLM intensifs, ils ajoutent une couche de friction inutile. Chaque appel passe par leur infrastructure, les logs sont opaques et le prompt caching d’Anthropic n’est pas exposé dans leurs connecteurs natifs.
Utilisée directement, l’API Anthropic expose des options d’optimisation que les orchestrateurs masquent. Le prompt caching stocke le contexte statique (brand guidelines, ton de voix, catalogue produit) côté Anthropic ; les lectures suivantes coûtent 10% du prix standard. Sur Haiku 4.5, un cache read descend à $0,10 par million de tokens contre $1 sans caching. Le Batch API, lui, passe les appels non-urgents à 50% du tarif synchrone, ce qui est utile pour les générations nocturnes. Et vous contrôlez exactement ce qui est envoyé : aucun token parasite injecté par l’orchestrateur.
Un bloc de guidelines de 4 000 tokens sur Claude Haiku 4.5 coûte $0,004 par appel sans caching. Sur 500 appels : $2. Avec caching activé, les 499 lectures après la première tombent à $0,0004. Les 500 appels : $0,60.
Prérequis techniques
Créez un compte sur console.anthropic.com, générez une clé API et installez le SDK :
pip install anthropic python-dotenvStockez votre clé dans un fichier .env :
ANTHROPIC_API_KEY=sk-ant-votre-cle-iciPour les workflows marketing en volume, utilisez claude-haiku-4-5. Pour du raisonnement plus profond (analyse concurrentielle, copywriting long format), passez sur claude-sonnet-4-6.
Génération de variantes publicitaires avec prompt caching
Ce script génère 500 variantes d’annonces Google Ads en réutilisant le même bloc de guidelines via le caching. Coût réel mesuré : environ $0,60 pour 500 appels sur Haiku 4.5.
import anthropic
import os
from dotenv import load_dotenv
load_dotenv()
client = anthropic.Anthropic()
# Bloc statique mis en cache : guidelines + catalogue
BRAND_CONTEXT = """
Vous êtes copywriter pour une SaaS B2B de gestion de factures.
Ton : professionnel, direct, sans jargon financier inutile.
USP : synchronisation comptable automatique en 2 clics.
Contrainte : titres Google Ads max 30 caractères, descriptions max 90 caractères.
Produits : Plan Starter (29€/mois), Plan Pro (79€/mois), Plan Enterprise (sur devis).
"""
def generate_ad_variant(product_name: str, target_persona: str, angle: str) -> dict:
response = client.messages.create(
model="claude-haiku-4-5",
max_tokens=300,
system=[
{
"type": "text",
"text": BRAND_CONTEXT,
"cache_control": {"type": "ephemeral"} # active le caching
}
],
messages=[
{
"role": "user",
"content": f"""Génère 3 variantes d'annonce Google Ads.
Produit : {product_name}
Persona : {target_persona}
Angle : {angle}
Format JSON strict :
{{
"headline_1": "...",
"headline_2": "...",
"description": "..."
}}"""
}
]
)
return response.content[0].text
# Exemple : 10 combinaisons persona x angle
personas = ["DAF PME", "Expert-comptable", "Dirigeant TPE"]
angles = ["gain de temps", "réduction d'erreurs", "conformité fiscale"]
results = []
for persona in personas:
for angle in angles:
variant = generate_ad_variant("Plan Pro", persona, angle)
results.append({"persona": persona, "angle": angle, "copy": variant})
print(f"✓ {persona} / {angle}")
# Sauvegarde
import json
with open("ad_variants.json", "w", encoding="utf-8") as f:
json.dump(results, f, ensure_ascii=False, indent=2)
print(f"\n{len(results)} variantes générées.")
Le champ cache_control: {"type": "ephemeral"} sur le bloc système active le caching pour 5 minutes. Tant que les appels s’enchaînent en moins de 5 minutes, chaque appel après le premier lit depuis le cache. Pour une exécution en batch nocturne, cette fenêtre suffit largement si vous chaînez les appels sans pause.
Pipeline email nurturing avec variables dynamiques
Ce pattern génère des séquences d’emails personnalisés à partir d’un CRM export CSV. Le system prompt contient la charte éditoriale (statique, mis en cache), les messages utilisateur portent uniquement les variables dynamiques.
import anthropic
import csv
import json
from pathlib import Path
client = anthropic.Anthropic()
EMAIL_GUIDELINES = """
Séquence nurturing B2B pour outil de marketing automation.
Ton : conversationnel mais expert. Pas de pression de vente directe.
Structure : contexte (1 phrase) + valeur (2-3 phrases) + CTA unique.
CTA autorisés : "Lire l'article", "Voir la démo", "Télécharger le guide".
Longueur cible : 80 à 120 mots par email.
Personnalisation obligatoire : prénom + secteur d'activité dans les 2 premières phrases.
"""
def generate_email(prenom: str, secteur: str, etape: int, sujet: str) -> str:
response = client.messages.create(
model="claude-haiku-4-5",
max_tokens=400,
system=[
{
"type": "text",
"text": EMAIL_GUIDELINES,
"cache_control": {"type": "ephemeral"}
}
],
messages=[
{
"role": "user",
"content": f"""Email nurturing étape {etape}/5.
Destinataire : {prenom}, responsable marketing dans le secteur {secteur}.
Sujet de l'email : {sujet}
Génère uniquement le corps de l'email, sans objet ni signature."""
}
]
)
return response.content[0].text
# Lecture du CRM export
contacts_path = Path("contacts.csv")
if not contacts_path.exists():
# Données de démonstration
contacts = [
{"prenom": "Sophie", "secteur": "e-commerce", "etape": 2},
{"prenom": "Marc", "secteur": "SaaS", "etape": 1},
{"prenom": "Julie", "secteur": "retail", "etape": 3},
]
else:
with open(contacts_path) as f:
contacts = list(csv.DictReader(f))
sujets = {
1: "Pourquoi vos emails ne sont pas ouverts",
2: "Le vrai coût de l'automation sans stratégie",
3: "Comment X a doublé son taux de conversion",
4: "Checklist : votre séquence nurturing en 5 étapes",
5: "Prêt à passer à l'étape suivante ?",
}
output = []
for contact in contacts:
etape = int(contact.get("etape", 1))
sujet = sujets.get(etape, sujets[1])
email_body = generate_email(
contact["prenom"],
contact["secteur"],
etape,
sujet
)
output.append({**contact, "email_body": email_body, "sujet": sujet})
print(f"Email généré pour {contact['prenom']} (étape {etape})")
with open("emails_generated.json", "w", encoding="utf-8") as f:
json.dump(output, f, ensure_ascii=False, indent=2)
Sur 200 contacts, le script tourne en 2 à 4 minutes. Moins de 0,50 euro sur Haiku 4.5 avec caching actif.
Repurposing de contenu multi-canal
À partir d’un article long, ce script génère les déclinaisons LinkedIn, Twitter/X et newsletter. Le même article source est passé une fois, les formats varient dans le message utilisateur.
import anthropic
import asyncio
client = anthropic.Anthropic()
CONTENT_STRATEGY = """
Content strategist pour une agence de marketing B2B.
Voix de marque : experte, directe, avec des données concrètes.
Pas d'emojis sauf dans les posts LinkedIn (max 2 par post).
LinkedIn : format "hook fort + développement en 3 points + question finale". 800 à 1200 caractères.
Twitter/X : tweet principal + 2 tweets de thread si nécessaire. 280 caractères max par tweet.
Newsletter : paragraphe de 120 à 180 mots, angle pédagogique, lien CTA à la fin.
"""
def generate_social_content(article_extract: str, platform: str) -> str:
platform_instruction = {
"linkedin": "Génère un post LinkedIn selon les guidelines.",
"twitter": "Génère un tweet principal + 2 tweets de suite (thread).",
"newsletter": "Génère le paragraphe newsletter avec CTA."
}
response = client.messages.create(
model="claude-haiku-4-5",
max_tokens=600,
system=[
{
"type": "text",
"text": CONTENT_STRATEGY,
"cache_control": {"type": "ephemeral"}
}
],
messages=[
{
"role": "user",
"content": f"""Article source :
---
{article_extract}
---
{platform_instruction[platform]}"""
}
]
)
return response.content[0].text
# Article source exemple
article = """
L'automatisation marketing par API LLM réduit les coûts de génération de contenu
de 60 à 90% par rapport aux abonnements SaaS classiques. Une équipe de 3 personnes
peut gérer 10x plus de canaux avec le même budget, à condition de structurer
correctement ses prompts et d'utiliser le caching pour les contextes statiques.
"""
platforms = ["linkedin", "twitter", "newsletter"]
results = {}
for platform in platforms:
results[platform] = generate_social_content(article, platform)
print(f"✓ {platform.capitalize()} généré")
for platform, content in results.items():
print(f"\n--- {platform.upper()} ---")
print(content)
Chaque déclinaison coûte entre $0,001 et $0,003 selon la longueur. Un calendrier éditorial de 20 articles/mois avec 3 formats chacun revient à moins de 2 euros.
Audit automatique de copy avec scoring
Ce script analyse votre copy existant (landing pages, emails, ads) et retourne un score structuré avec recommandations. Pratique avant un A/B test ou pour des audits réguliers sans passer par un consultant externe.
import anthropic
import json
client = anthropic.Anthropic()
AUDIT_FRAMEWORK = """
Expert en optimisation de copy B2B SaaS.
Critères d'évaluation (scoring sur 10 pour chacun) :
1. Clarté du value proposition (est-ce qu'on comprend en 5 secondes ce que ça fait ?)
2. Adressage du persona (le bon interlocuteur se reconnaît-il ?)
3. Preuves et chiffres (y a-t-il des éléments de réassurance concrets ?)
4. Urgence et CTA (l'action suivante est-elle claire et motivée ?)
5. Cohérence de ton (est-ce que ça correspond à une marque B2B sérieuse ?)
Retourne UNIQUEMENT du JSON valide avec la structure suivante :
{
"scores": {"clarté": 0, "persona": 0, "preuves": 0, "cta": 0, "ton": 0},
"score_global": 0,
"points_forts": ["..."],
"points_faibles": ["..."],
"recommandations_prioritaires": ["..."]
}
"""
def audit_copy(copy_text: str, context: str = "") -> dict:
response = client.messages.create(
model="claude-sonnet-4-6", # Sonnet pour la qualité d'analyse
max_tokens=800,
system=[
{
"type": "text",
"text": AUDIT_FRAMEWORK,
"cache_control": {"type": "ephemeral"}
}
],
messages=[
{
"role": "user",
"content": f"""Contexte : {context if context else "Landing page SaaS B2B"}
Copy à auditer :
---
{copy_text}
---
Retourne l'audit JSON."""
}
]
)
raw = response.content[0].text.strip()
# Extraction JSON robuste
if "```json" in raw:
raw = raw.split("```json")[1].split("```")[0].strip()
elif "```" in raw:
raw = raw.split("```")[1].split("```")[0].strip()
return json.loads(raw)
# Test sur un exemple
sample_copy = """
Notre logiciel de facturation automatique vous fait gagner du temps.
Essayez gratuitement pendant 14 jours.
Plus de 500 entreprises nous font confiance.
"""
result = audit_copy(
sample_copy,
context="Hero section landing page outil comptable"
)
print(f"Score global : {result['score_global']}/10")
print(f"Points forts : {result['points_forts']}")
print(f"Recommandations : {result['recommandations_prioritaires']}")
Utilisez Sonnet 4.6 pour ce pattern. Les audits sont peu nombreux (quelques dizaines par mois maximum) et la précision du raisonnement justifie le surcoût.
Combien ça coûte vraiment par mois
Coûts mesurés sur Haiku 4.5 avec caching activé :
| Usage | Volume mensuel | Coût sans caching | Coût avec caching |
|---|---|---|---|
| Variantes ads (4k tokens system) | 2 000 appels | 8,00 € | 0,90 € |
| Emails nurturing (2k tokens system) | 1 000 contacts | 2,00 € | 0,30 € |
| Repurposing contenu (1k tokens system) | 300 déclinaisons | 0,90 € | 0,20 € |
| Audits copy (Sonnet 4.6) | 50 audits | 2,50 € | 1,50 € |
| Total profil actif | – | 13,40 € | 2,90 € |
Pour un usage 10x plus intensif, comptez entre 20 et 28 euros par mois. Aucun abonnement n8n, aucun seat Make.
Les pièges qui font exploser la facture
Le prompt caching ne s’active que si le bloc system est identique à l’octet près entre les appels. Une variable dynamique glissée dans le system prompt casse le cache à chaque fois. Toutes les variables personnalisées vont dans le message utilisateur, pas dans le système.
Le cache dure 5 minutes par défaut. Si votre script fait des pauses longues entre les appels (lecture CSV lente, appels HTTP externes), le cache expire et vous repassez au plein tarif. Vérifiez avec response.usage.cache_read_input_tokens que le cache est bien utilisé.
Ne pas confondre Batch API et prompt caching. Le Batch API divise les coûts par deux mais les résultats arrivent avec 24h de délai. C’est pour les générations nocturnes, pas pour les workflows temps-réel. Combinés, les deux réductions sont multiplicatives : 90% (caching) x 50% (batch) = 95% d’économie sur les tokens d’entrée.
Stockez votre clé API dans une variable d’environnement, jamais en dur dans le code. Ajoutez .env à votre .gitignore. Les quotas Anthropic bloquent automatiquement les dépassements mais une clé exposée sur GitHub reste un incident de sécurité.
Ces quatre scripts couvrent les cas d’usage marketing les plus fréquents. Le meilleur point d’entrée : la génération de variantes publicitaires, là où le ratio volume/cache est le plus favorable.
