Accueil › Blog › Worker Claude Code

Claude Code · Automatisation

Claude Code en arrière-plan : vos automatisations sur votre forfait, pas sur l'API qui consomme des tokens

Vous payez déjà un forfait Claude Pro ou Max pour coder avec Claude Code. Pourtant, dès qu'il faut automatiser une tâche (classer des mails, analyser un ticket, préparer une réponse), le réflexe est de créer une clé API et de payer chaque token en plus. Pour vos propres outils, il existe une autre voie : un worker qui fait travailler Claude Code en tâche de fond.

Baptiste CloartBLV TECH · 21 octobre 2026 · 10 min de lecture

En bref

claude -p lance Claude Code sans interface, avec la connexion de votre compte claude.ai : la consommation est prise sur votre forfait, pas facturée au token.
Un worker est un petit programme qui tourne en continu sur votre poste, prend les tâches dans une file d'attente et appelle claude -p pour chacune.
C'est fait pour automatiser votre propre travail. Pour un produit utilisé par vos clients, la clé API reste la règle.

Deux factures pour la même IA

L'API Anthropic est facturée au token : chaque mot envoyé et reçu se paie. Sur une automatisation qui lit des fils de mails complets ou l'historique d'un ticket avec un modèle haut de gamme, la note grimpe vite et devient difficile à prévoir.

Le forfait, lui, a un prix fixe et des quotas d'utilisation. Si vos automatisations servent votre propre travail, les faire passer par ce forfait a du sens : tant que vous restez dans les quotas, elles ne vous coûtent rien de plus.

Le principe : `claude -p`, Claude Code sans interface

L'option -p (print) fait tourner Claude Code en mode non interactif : il lit un prompt, répond, puis s'arrête. Il utilise exactement la même authentification que votre terminal. Si vous êtes connecté avec votre compte Claude, c'est votre forfait qui est décompté.

# Le prompt arrive par l'entrée standard, la réponse sort en JSON echo "Résume ce mail en une phrase : ..." | claude -p --output-format json

La sortie est une enveloppe JSON : le texte de la réponse dans result, un indicateur is_error. Avec --json-schema, Claude doit en plus renvoyer un objet conforme à votre schéma, dans structured_output. Votre code reçoit des données, plus du texte à découper.

Le worker : une file d'attente, une boucle, Claude

Le worker relie le monde extérieur à claude -p. Les demandes sont déposées dans une file d'attente ; le worker, qui tourne sur votre poste, les prend une par une, appelle Claude, puis écrit le résultat. Pour démarrer, un simple dossier suffit comme file d'attente. Une table en base prend le relais quand plusieurs sources ou plusieurs machines entrent en jeu.

1

Source

Mail, formulaire, fichier déposé

2

File d'attente

Un dossier ou une table en base

3

Worker

Sur votre PC, en continu

4

claude -p

Votre forfait Pro ou Max

5

Résultat

Écrit en base, affiché dans l'outil

Le worker ne fait que des connexions sortantes : aucun port ouvert, aucun PC exposé sur Internet.

Quatre règles rendent l'ensemble fiable :

Le worker va chercher le travail : rien ne se connecte au PC, c'est lui qui relève la file d'attente.
Une tâche n'est traitée qu'une fois : on la déplace (dossier) ou on la verrouille (FOR UPDATE SKIP LOCKED en base) dès qu'on la prend.
Chaque appel a un délai maximum : une tâche en échec part en erreur, on la relance à la main au lieu de boucler dessus.
Il démarre tout seul avec la session et redémarre s'il s'arrête.

Exemple concret : trier vos demandes clients

Vous recevez des demandes par mail ou par le formulaire de votre site : bugs, questions, devis… Chaque matin, il faut les lire, repérer l'urgent et préparer une réponse. On confie ce tri à un worker.

Chaque demande arrive sous forme de fichier texte dans un dossier entree/ (export de mail, script du formulaire, copier-coller).
Le worker regarde ce dossier toutes les deux secondes.
Pour chaque fichier, Claude renvoie la catégorie, l'urgence, un résumé en une phrase et une proposition de réponse.
Le résultat est écrit en JSON dans sortie/ et la demande est rangée dans traite/.

Ce qui entre : entree/demande-001.txt

Bonjour, depuis ce matin impossible de me connecter à l'espace client : message « mot de passe expiré » alors que je l'ai changé hier. C'est bloquant pour valider les commandes du jour. Merci, Julie

Ce qui sort : sortie/demande-001.json

{ "categorie": "bug", "urgence": "haute", "resume": "Connexion impossible (mot de passe expiré), bloque les commandes du jour.", "reponse": "Bonjour Julie, merci pour votre message. Nous regardons tout de suite…" }

Deux fichiers suffisent : une fonction qui appelle Claude, et la boucle du worker.

claude.mjs : appeler Claude sur le forfait

import { spawn } from 'node:child_process' import os from 'node:os' // Claude Code sans interface, sur le forfait du compte connecté. // Installé par npm sous Windows : CLAUDE_EXE = chemin complet de claude.exe // (…\npm\node_modules\@anthropic-ai\claude-code\bin\claude.exe). const CLAUDE = process.env.CLAUDE_EXE ?? 'claude' export function claude(prompt, { schema, modele = 'sonnet', delaiMs = 180_000 } = {}) { const args = ['-p', '--safe-mode', '--tools', '', '--no-session-persistence', '--output-format', 'json', '--model', modele] if (schema) args.push('--json-schema', JSON.stringify(schema)) return new Promise((ok, ko) => { const p = spawn(CLAUDE, args, { cwd: os.tmpdir(), windowsHide: true }) let sortie = '', erreurs = '' const minuterie = setTimeout(() => { p.kill(); ko(new Error('délai dépassé')) }, delaiMs) p.stdout.on('data', (d) => (sortie += d)) p.stderr.on('data', (d) => (erreurs += d)) p.on('close', (code) => { clearTimeout(minuterie) try { const r = JSON.parse(sortie) if (r.is_error) return ko(new Error(r.result)) ok(schema ? r.structured_output : r.result) } catch { ko(new Error(`claude -p (code ${code}) : ${erreurs || sortie}`)) } }) p.stdin.end(prompt, 'utf8') // pas de limite de longueur de ligne de commande }) }

worker.mjs : la boucle

import fs from 'node:fs/promises' import path from 'node:path' import { claude } from './claude.mjs' // La forme exacte de la réponse attendue const SCHEMA = { type: 'object', properties: { categorie: { type: 'string', enum: ['bug', 'question', 'devis', 'autre'] }, urgence: { type: 'string', enum: ['basse', 'normale', 'haute'] }, resume: { type: 'string' }, reponse: { type: 'string' }, }, required: ['categorie', 'urgence', 'resume', 'reponse'], } for (const d of ['entree', 'sortie', 'traite', 'erreur']) await fs.mkdir(d, { recursive: true }) for (;;) { for (const f of (await fs.readdir('entree')).filter((n) => n.endsWith('.txt'))) { const texte = await fs.readFile(path.join('entree', f), 'utf8') try { const r = await claude(`Tu tries les demandes reçues par une petite entreprise. Classe la demande ci-dessous, résume-la en une phrase et propose une réponse courte et polie. <demande> ${texte} </demande>`, { schema: SCHEMA }) await fs.writeFile(path.join('sortie', f.replace(/\.txt$/, '.json')), JSON.stringify(r, null, 2)) await fs.rename(path.join('entree', f), path.join('traite', f)) console.log(`${f} : ${r.categorie}, urgence ${r.urgence}`) } catch (e) { console.error(`${f} : ${e.message}`) await fs.rename(path.join('entree', f), path.join('erreur', f)) // à relancer à la main } } await new Promise((ok) => setTimeout(ok, 2000)) }

Lancer et tester

# Prérequis : Node.js 18+ et Claude Code connecté à votre compte (commande claude, puis /login) node worker.mjs # Dans un autre terminal : déposer une demande echo "Bonjour, pouvez-vous m'envoyer un devis pour 3 licences ?" > entree/demande-002.txt

Quelques secondes plus tard, sortie/demande-002.json apparaît avec la catégorie devis. Aucun appel n'a été facturé à l'API : tout a été pris sur votre forfait. Pour aller plus loin, il suffit de changer la source (lire une boîte mail, recevoir le formulaire) ou la sortie (créer une tâche, envoyer une notification) : la boucle reste la même.

Les options qui comptent

Option	Pourquoi
`-p`	Mode non interactif : lit le prompt, répond, s'arrête.
`--output-format json`	Une enveloppe JSON simple à lire depuis le code.
`--json-schema`	Impose la forme de la réponse : des données fiables, pas du texte libre.
`--safe-mode`	Ignore votre configuration personnelle (CLAUDE.md, skills, hooks, serveurs MCP) tout en gardant la connexion au forfait. Sans elle, le worker hérite de vos consignes et déclenche vos hooks à chaque appel. À ne pas confondre avec `--bare`, qui exige une clé API.
`--tools ""`	Aucun outil : Claude ne lit pas vos fichiers et ne lance aucune commande. Il travaille uniquement sur le texte fourni.
`--no-session-persistence`	N'enregistre pas la session : votre historique de conversations reste propre.
`--model`, `--effort`	Adapter la puissance à la tâche : un classement n'a pas besoin du plus gros modèle.

Le faire tourner en continu

Sous Windows, une tâche planifiée lance le worker à l'ouverture de session, sans fenêtre, et le relance en cas d'arrêt. Sous Linux ou macOS, un service systemd utilisateur ou un agent launchd fait la même chose. Point important : il doit tourner sous le compte où claude est connecté, car la connexion est propre à chaque utilisateur.

# Windows : tâche planifiée à l'ouverture de session, relancée chaque minute en cas d'arrêt $action = New-ScheduledTaskAction -Execute 'node' -Argument 'worker.mjs' -WorkingDirectory 'C:\worker' $trigger = New-ScheduledTaskTrigger -AtLogOn -User $env:USERNAME $settings = New-ScheduledTaskSettingsSet -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1) ` -ExecutionTimeLimit ([TimeSpan]::Zero) -MultipleInstances IgnoreNew Register-ScheduledTask -TaskName 'Worker Claude' -Action $action -Trigger $trigger -Settings $settings

Les contraintes à connaître avant de se lancer

Ce fonctionnement a de vraies limites. Mieux vaut les connaître avant de bâtir dessus.

1. Un usage personnel, pas un produit

Le forfait couvre votre usage de Claude Code. Anthropic l'écrit clairement : les limites des forfaits Pro et Max supposent un usage ordinaire et individuel, et il est interdit de faire passer les requêtes de vos utilisateurs par vos identifiants.

Automatiser votre travail (vos mails, vos tickets, vos rapports) : oui. Faire tourner le service que vous vendez à vos clients : non, c'est une clé API. Référence : conditions d'utilisation de Claude Code.

2. Des quotas partagés avec vous

Le forfait a une limite par fenêtre de cinq heures et une limite hebdomadaire, communes à claude.ai, à Claude Code et à votre worker. Un worker trop gourmand peut vous bloquer en pleine journée de développement.

Parades : traiter sans IA tout ce qui peut l'être (doublons, réponses à un échange déjà connu, filtres simples), choisir un modèle et un effort adaptés à chaque tâche, ne jamais relancer en boucle une tâche qui échoue.

3. Une machine allumée, sans garantie de service

Pas de PC, pas de traitement. La file d'attente évite de perdre quoi que ce soit (tout est repris au redémarrage), mais personne ne garantit le délai.

Et un PC éteint ne peut pas prévenir de sa propre absence : faites écrire au worker un signal de vie régulier (une date en base, par exemple) et surveillez-le depuis l'extérieur.

4. Quelques secondes par appel

Chaque appel démarre un processus Claude Code : comptez plusieurs secondes avant la réponse. Parfait pour du travail en arrière-plan, inadapté à un assistant public en temps réel ou à des milliers de traitements en parallèle.

5. Le piège de `ANTHROPIC_API_KEY`

Si cette variable d'environnement existe sur la machine, Claude Code l'utilise à la place de votre forfait : le worker est alors facturé à l'API, sans prévenir. Vérifiez l'environnement du compte qui exécute le worker, variables système comprises.

6. Sécurité et données

Le contenu traité n'est pas fiable : un mail peut contenir des instructions destinées à l'IA. Pour un classement, aucun outil (--tools "") ; pour un agent, lecture seule et une liste fermée de commandes autorisées.

Les données passent par votre compte Claude : vérifiez ses paramètres de confidentialité avant d'y faire transiter des données clients.

7. De la maintenance

Claude Code évolue vite : une option peut changer de comportement d'une version à l'autre. Testez après chaque mise à jour, journalisez chaque appel et surveillez la connexion : si elle expire, le worker échoue jusqu'à ce que vous vous reconnectiez.

Forfait ou API : comment choisir ?

	Worker sur le forfait	API Anthropic
Coût	Inclus dans l'abonnement, dans la limite des quotas	Au token : variable, sans plafond
Pour qui	Vous seul : vos outils internes	Vos clients, votre produit
Disponibilité	Celle de votre poste	Service en ligne, en continu
Réactivité	Quelques secondes par appel	Appel HTTP direct, réponse en flux
Volume	Limité par les quotas et une machine	Selon votre palier d'usage
Mise en place	Un script et `claude` connecté	Clé API, facturation, suivi des coûts

Mon conseil : démarrez par le worker pour vos propres automatisations. Vous validez le prompt, le schéma de réponse et l'intérêt réel de l'automatisation sans dépenser un centime de plus. Le jour où l'outil doit servir d'autres personnes, passez à l'API : le prompt et le schéma restent les mêmes, seul l'appel change.

Sur mesure

Automatiser vos process avec Claude ?

J'accompagne les PME et les développeurs : worker sur forfait pour vos outils internes, intégration API pour vos produits, skills branchés sur vos données.