# Exécuter des tâches récurrentes avec un agent

Réutilisez l’accès approuvé, effectuez une recherche par occurrence planifiée et reprenez une exécution sans soumettre accidentellement la même tâche deux fois.

Référence canonique : https://flashdata.dev/fr/docs/guides/recurring-tasks
Vérifié le 2026-11-05 par FlashData

<a id="choose"></a>

## Choisir le mode d’exécution

Votre hôte d’agent ou le planificateur du système gère les horaires. FlashData fournit les données. Choisissez un mode d’exécution et testez-le dans l’environnement qui fonctionnera sans intervention.

| Interface | Usage | État à conserver |
| --- | --- | --- |
| CLI | Un agent disposant d’un terminal, cron ou un script planifié. | Le profil CLI, le répertoire d’état et l’identifiant d’exécution d’origine. |
| MCP | Un hôte d’agent connecté à un serveur FlashData. | Les identifiants de l’hôte, l’enregistrement de l’occurrence, les identifiants de tâches et les résultats. |

- [Tâche CLI](https://flashdata.dev/fr/docs/guides/recurring-tasks/reference.md#input)
- [Tâche MCP](https://flashdata.dev/fr/docs/guides/recurring-tasks/reference.md#mcp)
- [Créer une synthèse quotidienne](https://flashdata.dev/fr/docs/guides/daily-research-briefing/reference.md)

<a id="prepare"></a>

## Vérifier l’accès dans l’environnement planifié

Réutilisez une connexion propriétaire existante disposant de la permission google_search. Rattachez l’accès temporaire à un compte avant toute utilisation récurrente. Testez depuis un nouveau processus ou une nouvelle session planifiée, et pas seulement depuis une session interactive.

### CLI

Utilisez Bash et jq (Git Bash sous Windows), avec l’utilisateur du système qui a enregistré la clé. Indiquez ci-dessous le nom de votre profil existant et le chemin absolu de son répertoire d’état. Exécutez les deux blocs dans le même terminal ; le script réutilise ces paramètres.

La vérification d’accès doit afficher true. Comparez availableCredits à estimatedCredits avant la première recherche. Ces vérifications ne soumettent aucune requête de données.

#### Sélectionner votre connexion enregistrée

```bash
# Use the profile and state directory that already hold your owner key.
export FLASHDATA_PROFILE='research'
export FLASHDATA_STATE_DIR='/absolute/path/to/existing/flashdata-state'
export FLASHDATA_BIN="$(command -v flashdata)"
unset FLASHDATA_API_KEY
```

#### Vérifier gratuitement l’accès, le solde et le prix

```bash
set -euo pipefail
export FLASHDATA_BIN="${FLASHDATA_BIN:-$(command -v flashdata)}"
: "${FLASHDATA_STATE_DIR:?Set the existing absolute state directory}"
: "${FLASHDATA_BIN:?Set the absolute path to the FlashData executable}"
profile=${FLASHDATA_PROFILE:-research}
test -d "$FLASHDATA_STATE_DIR" || { echo 'Existing state directory not found.' >&2; exit 1; }
"$FLASHDATA_BIN" --version
jq --version
"$FLASHDATA_BIN" auth status --profile "$profile" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive |
  jq -e '.ok and .data.accessVerified
    and (.data.identity.identity.recurringAllowed == true)
    and (.data.identity.permittedSources | index("google_search") != null)'
"$FLASHDATA_BIN" account balance --profile "$profile" \
  --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
"$FLASHDATA_BIN" account pricing --source google_search --request-count 1 \
  --profile "$profile" --state-dir "$FLASHDATA_STATE_DIR" --json --non-interactive
```


### MCP

Exécutez cette consigne dans une nouvelle session planifiée. Laissez l’hôte réutiliser et renouveler ses identifiants OAuth approuvés. Il doit pouvoir accéder à FlashData sans connexion interactive à chaque exécution.

#### Vérification gratuite dans l’hôte

```text
Réutilisez la connexion MCP FlashData existante dans cet environnement planifié.
Appelez get_balance avec {}.
Appelez get_pricing avec {"source":"google_search","request_count":1}.
Indiquez le solde et le coût estimé. Ne lancez aucune recherche et ne créez pas de nouvel accès.
```


- [Installer la CLI](https://flashdata.dev/fr/docs/guides/flashdata-cli/reference.md#install)
- [Connecter MCP](https://flashdata.dev/fr/docs/integrations/mcp-clients/reference.md)
- [Rattacher l’accès d’essai](https://flashdata.dev/fr/docs/guides/agent-onboarding/reference.md#claim)

<a id="input"></a>

## CLI : enregistrer une tâche par occurrence

Créez le dossier de tâche ci-dessous, puis enregistrez-y request.json et run-research.sh. Gardez ce dossier séparé du répertoire d’état qui contient les identifiants existants. Une date correspond à une requête Google ; num définit le nombre de résultats. Attribuez à chaque autre workflow son propre préfixe d’identifiant d’exécution avant de le lancer.

### Créer le dossier de tâche

```bash
mkdir -p flashdata-research
cd flashdata-research
```

### request.json

```json
{
  "source": "google_search",
  "query": "battery recycling research",
  "params": {
    "num": 5
  }
}
```


<a id="runner"></a>

### Enregistrer run-research.sh

Créez run-research.sh à côté de request.json dans le dossier de tâche. Copiez-y le script complet ci-dessous et enregistrez-le avant d’exécuter ou de planifier la tâche.

Le script fige les paramètres de chaque date et conserve un reçu, un résultat et un fichier d’erreur par tentative. Seules les tentatives réussies publient result.json et receipt.json à la racine du dossier daté. --recurring vérifie l’accès propriétaire ; cette option ne crée pas de planification.

#### run-research.sh

```bash
#!/usr/bin/env bash
set -euo pipefail
umask 077
slot=${1:?Pass the scheduled date as YYYY-MM-DD}
[[ "$slot" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}$ ]] || exit 2
: "${FLASHDATA_STATE_DIR:?Set the existing absolute state directory}"
: "${FLASHDATA_BIN:?Set the absolute path to the FlashData executable}"
profile=${FLASHDATA_PROFILE:-research}
cd -- "$(dirname -- "$0")"
dir="runs/$slot"
mkdir -p "$dir"
if [[ -e "$dir/request.json" ]]; then
  cmp -s request.json "$dir/request.json" || {
    echo 'Input changed for this slot. Inspect its saved run.' >&2; exit 1;
  }
else
  (set -C; cat request.json > "$dir/request.json")
fi
attempt=$(mktemp -d "$dir/attempt.XXXXXX")
if ! "$FLASHDATA_BIN" query --input "$dir/request.json" --recurring \
  --run-id "scheduled-research:$slot:Asia-Shanghai" \
  --profile "$profile" --state-dir "$FLASHDATA_STATE_DIR" \
  --output "$attempt/result.json" --timeout 2m --json --non-interactive \
  > "$attempt/receipt.json" 2> "$attempt/error.json"; then
  cat "$attempt/error.json" >&2
  exit 1
fi
jq -e '.ok == true' "$attempt/receipt.json" >/dev/null
jq -e '.source == "google_search" and .status == "done"
  and (.results[0].organic | type == "array")' "$attempt/result.json" >/dev/null
# Publish a stable path only after the query and its receipt both succeed.
cp "$attempt/result.json" "$dir/result.next.json"
mv "$dir/result.next.json" "$dir/result.json"
cp "$attempt/receipt.json" "$dir/receipt.next.json"
mv "$dir/receipt.next.json" "$dir/receipt.json"
jq '{runId, cached, usage}' "$attempt/receipt.json"
printf 'Saved result: %s\n' "$dir/result.json"
```


<a id="slot"></a>

### Exécuter une fois, puis réessayer depuis un nouveau processus

Exécutez les commandes depuis le dossier de tâche. La première soumet une recherche. La seconde utilise le même compte, les mêmes paramètres, le même profil et le même état pour lire le résultat enregistré, après avoir vérifié que l’accès est toujours valide.

#### Une occurrence · deux lancements de processus

```bash
# Use the date of the intended occurrence, including on retries.
bash run-research.sh 2026-11-04

# Same account, input, profile and state: reuse the completed run.
bash run-research.sh 2026-11-04
```


<a id="result"></a>

### Confirmer la réutilisation du résultat

Le second reçu doit indiquer cached: true. Sa consommation correspond à la recherche d’origine. Un tableau organic vide peut tout de même constituer un résultat réussi.

#### Examiner le résultat et le reçu enregistrés

```bash
jq '{ok, runId, cached, usage}' runs/2026-11-04/receipt.json
jq '.results[0].organic | map({title, link})' runs/2026-11-04/result.json
```

#### Second reçu · extrait

```json
{
  "schemaVersion": 1,
  "ok": true,
  "runId": "scheduled-research:2026-11-04:Asia-Shanghai",
  "cached": true
}
```


<a id="files"></a>

### Conserver les fichiers entre les exécutions

| Fichier | Utilité |
| --- | --- |
| runs/DATE/request.json | Paramètres exacts de cette occurrence ; toute modification arrête le script. |
| runs/DATE/result.json + receipt.json | La dernière tentative réussie. Ne les utilisez qu’après la réussite de la commande en cours. |
| runs/DATE/attempt.*/ | Résultat, reçu et erreur de chaque tentative, y compris les échecs. |
| FLASHDATA_STATE_DIR | Identifiants protégés et historique des exécutions CLI. Conservez le même profil et le même utilisateur du système. |

- [Reprendre une exécution interrompue](https://flashdata.dev/fr/docs/guides/agent-recovery/reference.md)

<a id="mcp"></a>

## MCP : conserver l’occurrence et l’identifiant de tâche

Utilisez cette consigne avec un hôte qui conserve durablement l’état des tâches et n’autorise qu’une exécution active par occurrence. Enregistrez immédiatement l’identifiant de tâche reçu ; après un redémarrage, consultez la tâche acceptée au lieu de relancer une recherche.

### Tâche MCP récurrente · enregistrer dans recurring-task.txt

```text
Utilisez l’identifiant d’occurrence et l’heure planifiée d’origine du planificateur.
Réutilisez la connexion MCP FlashData existante et l’enregistrement sauvegardé de cette occurrence.
1. Si cette occurrence est terminée, renvoyez son résultat enregistré sans nouvelle recherche.
2. Si elle possède un identifiant de tâche, appelez get_job avec ce job_id pour lire la tâche existante.
3. Si une soumission a commencé sans résultat ni identifiant de tâche, arrêtez pour examen.
4. Pour une nouvelle occurrence, vérifiez get_balance et get_pricing pour une requête google_search.
   Continuez uniquement dans les limites du budget approuvé par tâche et du solde disponible.
5. Enregistrez submission_started avant d’appeler google_search une seule fois avec :
   {"query":"battery recycling pilot plant announcements","num":5,"gl":"us","hl":"en","tbs":"qdr:w","mode":"async"}
6. Enregistrez immédiatement l’identifiant reçu. Consultez la tâche avec get_job jusqu’à un état final ; arrêtez en cas d’échec.
   Conservez cet identifiant lors des dépassements de délai et cessez d’attendre à l’échéance fixée par l’hôte.
7. Enregistrez le résultat, les URL sources et la consommation, puis marquez cette occurrence comme terminée.
En cas de 401, 403, 402, 429 ou de résultat inconnu, arrêtez et présentez l’enregistrement sauvegardé.
Respectez Retry-After. Ne créez pas d’accès de remplacement ni de nouvelle requête payante.
Conservez le rapport localement ; utilisez une destination de livraison uniquement si elle a été configurée séparément.
```

- [Outils MCP](https://flashdata.dev/fr/docs/mcp/reference.md)
- [Consulter une tâche acceptée](https://flashdata.dev/fr/docs/mcp/reference.md#jobs)

<a id="mcp-retries"></a>

### État que l’hôte doit conserver

Une consigne seule ne suffit pas à éviter les doublons. Les appels MCP ne bénéficient pas de la protection par identifiant d’exécution de la CLI. Votre hôte doit conserver l’occurrence d’origine, l’état de soumission et l’identifiant de tâche. S’il ne le peut pas, utilisez le script CLI pour l’étape de collecte des données. Cet exemple d’enregistrement appartient à votre hôte ; ce n’est pas une requête MCP.

#### Enregistrement de l’hôte · exemple

```json
{
  "occurrence": "research:2026-11-04:Asia-Shanghai",
  "state": "accepted",
  "job_id": "<returned job ID>",
  "output": null
}
```


<a id="schedule"></a>

## Planifier la tâche testée

L’exemple ci-dessous utilise OpenClaw à 09:00 Asia/Shanghai. Créez la tâche avec sa planification désactivée, lancez-la manuellement, examinez son résultat, puis activez-la. Avec un autre planificateur, suivez la même séquence à l’aide de ses commandes de test.

| Paramètre | Réglage |
| --- | --- |
| Exécutions simultanées | Une seule exécution active pour ce workflow, avec un état conservé durablement. |
| Environnement d’exécution | Utilisez le même utilisateur du système et des chemins absolus pour la CLI, le dossier de tâche et le répertoire d’état des identifiants. Les variables exportées dans un terminal ne sont pas automatiquement transmises à une passerelle déjà démarrée. |
| Nouvelles tentatives | Conservez l’occurrence et la date planifiée d’origine, même après minuit. Un test manuel utilise sa date de lancement dans le fuseau Asia/Shanghai. |
| Occurrences manquées | Choisissez de les ignorer ou de les rattraper. Une recherche exécutée aujourd’hui renvoie les données actuelles, même si elle porte la date d’hier. |
| Envoi du rapport | Enregistrez d’abord les rapports localement. Configurez une destination et des règles de notification avant de les envoyer. |

- [Préparer un serveur ou un conteneur](https://flashdata.dev/fr/docs/guides/production-deployment/reference.md)

<a id="cli-task"></a>

### Consigne CLI pour un hôte d’agent

Remplacez les valeurs de profil et de chemin, puis enregistrez recurring-task.txt dans le dossier de tâche. Utilisez cette consigne pour une exécution CLI, ou la consigne MCP ci-dessus pour une exécution MCP. Un planificateur système peut exécuter directement le script Bash avec ces variables d’environnement, sans modèle IA.

#### recurring-task.txt

```text
Exécutez la recherche FlashData approuvée avec l’utilisateur du système qui a enregistré la clé.
Script : <chemin absolu vers run-research.sh>
Définissez ces variables d’environnement pour le processus :
FLASHDATA_BIN: <chemin absolu vers flashdata>
FLASHDATA_PROFILE: <nom du profil existant>
FLASHDATA_STATE_DIR: <chemin absolu du répertoire d’état existant>
Laissez FLASHDATA_API_KEY non définie pour réutiliser les identifiants enregistrés.
Utilisez la date initialement planifiée dans Asia/Shanghai, au format YYYY-MM-DD.
Pour une exécution manuelle, enregistrez sa date de lancement avant de commencer.
Commande : bash "<chemin absolu vers run-research.sh>" YYYY-MM-DD
Conservez cette date lors des nouvelles tentatives, même après minuit. Une seule exécution doit être active.
Conservez le même profil, request.json et répertoire d’état.
Ne lisez le fichier result.json daté qu’après la réussite de la commande.
Indiquez les liens sources, l’identifiant d’exécution et la consommation. Gardez les sorties en local.
En cas d’erreur, arrêtez et indiquez l’erreur enregistrée. Ne démarrez pas de tâche de remplacement et ne créez pas de nouvel accès.
```


<a id="openclaw-schedule"></a>

### 1. Créer une tâche OpenClaw désactivée

Utilisez une passerelle en cours d’exécution et un agent existant ayant réussi la vérification d’accès. Les commandes ci-dessous utilisent OpenClaw 2026.10.10 ; mettez à jour les anciens clients si --wait n’est pas disponible. Dans le dossier contenant recurring-task.txt, définissez OPENCLAW_AGENT_ID avec l’identifiant de cet agent.

La commande enregistre openclaw-job.json sans écraser de fichier existant. Lisez-le et définissez OPENCLAW_JOB_ID avec l’identifiant de tâche reçu. Si la réponse de création est perdue, consultez automations list --all --json avant de créer une autre tâche. --no-deliver désactive les annonces automatiques ; la consigne conserve aussi les rapports en local.

#### Bash · créer une tâche désactivée

```bash
: "${OPENCLAW_AGENT_ID:?Set the existing OpenClaw agent ID}"
test -s recurring-task.txt || exit 1
# Keep the receipt. An existing file blocks accidental recreation.
(
  set -o noclobber
  openclaw automations add --name flashdata-daily-research \
    --agent "$OPENCLAW_AGENT_ID" \
    --cron "0 9 * * *" --tz Asia/Shanghai --exact \
    --session isolated --disabled --no-deliver \
    --message "$(cat recurring-task.txt)" --json > openclaw-job.json
)
```

- [Configurer OpenClaw](https://flashdata.dev/fr/docs/integrations/openclaw/reference.md)
- [Référence de planification OpenClaw](https://docs.openclaw.ai/cli/cron)

<a id="test-schedule"></a>

### 2. Tester la tâche enregistrée avant de l’activer

Exécutez la tâche enregistrée une fois en laissant sa planification désactivée. Prévoyez le coût d’une recherche de test et du modèle ; une occurrence CLI correspondante déjà terminée peut réutiliser son résultat. Cette commande attend jusqu’à 10 minutes.

Vérifiez completionStatus: succeeded, puis le résultat enregistré, les liens sources et la consommation. Avec la CLI, lisez runs/DATE/result.json et receipt.json ; avec MCP, consultez l’occurrence enregistrée par l’hôte et le résultat de la tâche. enqueued: true seul indique une acceptation, pas une exécution terminée.

#### Exécuter une fois · enregistrer le reçu du test

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
# Run the saved job once; its schedule stays disabled.
(
  set -o noclobber
  openclaw automations run "$OPENCLAW_JOB_ID" \
    --wait --wait-timeout 10m --json > openclaw-test-run.json
)
```

#### Lire le reçu du test

```bash
cat openclaw-test-run.json
```


<a id="inspect-test"></a>

### Examiner un test en échec ou dont le délai est dépassé

Un dépassement de délai arrête l’attente, pas la tâche de la passerelle. Consultez l’historique récent si le reçu est vide. Définissez OPENCLAW_RUN_ID avec le runId OpenClaw figurant dans le reçu ou l’historique, puis examinez cette exécution. Ne répétez pas la commande de lancement pour vérifier l’avancement.

Il s’agit de l’identifiant d’exécution du planificateur, pas de l’identifiant d’exécution récurrente FlashData ni d’un identifiant de tâche de données MCP. Si l’agent n’a pas pu se connecter ou exécuter la collecte, gardez la planification désactivée et corrigez d’abord cette étape.

#### Examiner la même exécution

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
cat openclaw-test-run.json
openclaw automations runs "$OPENCLAW_JOB_ID" --limit 5 --json

# Set this from the receipt or history; this is OpenClaw's run ID.
: "${OPENCLAW_RUN_ID:?Set the OpenClaw test run ID}"
openclaw automations runs "$OPENCLAW_JOB_ID" \
  --run-id "$OPENCLAW_RUN_ID" --json
```

- [Reprendre l’étape de collecte FlashData](https://flashdata.dev/fr/docs/guides/agent-recovery/reference.md)

<a id="manage-schedule"></a>

### 3. Activer après vérification du résultat

Vérifiez l’agent enregistré, la planification, le fuseau horaire et le test terminé. Activez la planification après avoir vérifié le résultat et approuvé le coût récurrent. Une désactivation ultérieure arrête les prochains lancements ; elle n’annule pas une requête déjà soumise.

#### Vérifier la tâche enregistrée et l’historique des tests

```bash
: "${OPENCLAW_JOB_ID:?Set the saved OpenClaw job ID}"
openclaw automations show "$OPENCLAW_JOB_ID" --json
openclaw automations runs "$OPENCLAW_JOB_ID" --limit 5 --json
```

#### Activer la planification quotidienne

```bash
openclaw automations enable "$OPENCLAW_JOB_ID"
```

#### Suspendre les prochaines exécutions si nécessaire

```bash
openclaw automations disable "$OPENCLAW_JOB_ID"
```


<a id="budget"></a>

## Définir les règles de coût et de gestion des échecs

| Situation | Action |
| --- | --- |
| Prévision du coût | Prix par requête × nombre d’occurrences prévues. Ajoutez séparément les coûts du modèle et de l’hôte ; le nombre de résultats n’est pas le nombre de requêtes. |
| Solde partagé du compte | Faites respecter votre budget dans le planificateur ou l’hôte. Ces exemples ne définissent pas de plafond de dépenses propre à la clé. |
| 401 / 403 / 402 | Suspendez les prochains lancements. Corrigez les identifiants, la permission ou le solde, puis reprenez avec l’occurrence d’origine et l’état enregistré. |
| 429 | Respectez Retry-After. Examinez l’exécution CLI ou l’occurrence MCP avant de décider si une nouvelle soumission est appropriée. |
| Résultat de soumission inconnu | Conservez l’état enregistré et arrêtez. Reprenez la tâche à partir de son identifiant connu ; ne créez pas de nouvel identifiant d’exécution pour contourner l’incertitude. |

- [Tarifs actuels](https://flashdata.dev/fr/pricing)
- [Choisir comment reprendre](https://flashdata.dev/fr/docs/guides/agent-recovery/reference.md)

<a id="stop"></a>

## Arrêter la planification et révoquer l’accès séparément

1. Mettez le planificateur en pause pour arrêter les prochains lancements.
2. Révoquez la connexion de l’agent, l’application OAuth ou la clé API dans la console. La révocation bloque toute nouvelle utilisation authentifiée ; elle n’efface pas les fichiers exportés.
3. Répétez la vérification gratuite d’accès depuis un nouveau processus. Elle doit échouer après la révocation. La commande CLI auth logout supprime uniquement les identifiants locaux ; elle ne révoque pas l’accès distant.

- [Applications et agents connectés](https://flashdata.dev/app/settings/connections)
- [Clés API](https://flashdata.dev/app/api-keys)
- [Cycle de vie de l’accès](https://flashdata.dev/fr/docs/guides/agent-access/reference.md)
