---
title: Déploiements planifiés
url: https://platform.claude.com/docs/fr/managed-agents/scheduled-deployments
description: "Créez et gérez des déploiements avec l'API Claude : exécutez un agent selon une planification cron récurrente et consultez son historique d'exécutions."
featureMetadata:
topic:
title: Managed Agents
url: https://platform.claude.com/docs/en/managed-agents/overview
status: beta
betaHeader: managed-agents-2026-04-01
---
Un « **scheduled deployment** » (**déploiement planifié**) permet à un [agent](https://platform.claude.com/docs/fr/managed-agents/agent-setup) de démarrer des [sessions](https://platform.claude.com/docs/fr/managed-agents/sessions) de manière autonome, ce qui permet d'accomplir des tâches selon une cadence prévisible. Vous créez et gérez les déploiements avec l'API Deployments, qui fait partie de l'API Claude.
Pour le contexte du lancement et des exemples de ce que les équipes exécutent selon une planification, consultez [scheduled deployments and vaults in Claude Managed Agents](https://claude.com/blog/whats-new-in-claude-managed-agents) sur le blog.
## Créer un déploiement planifié
Lors de la création d'un déploiement, vous transmettez les [configurations de session](https://platform.claude.com/docs/fr/managed-agents/sessions) nécessaires à l'exécution, en plus d'un `schedule` (csharp, go: `Schedule`).
* Les déploiements nécessitent une [configuration d'agent](https://platform.claude.com/docs/fr/managed-agents/agent-setup) et une [configuration d'environnement](https://platform.claude.com/docs/fr/managed-agents/environments), et acceptent facultativement des [fichiers](https://platform.claude.com/docs/fr/managed-agents/files), [GitHub](https://platform.claude.com/docs/fr/managed-agents/github), des [magasins de mémoire](https://platform.claude.com/docs/fr/managed-agents/memory) et des [coffres](https://platform.claude.com/docs/fr/managed-agents/vaults). Un déploiement qui cible un [environnement auto-hébergé](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory) peut associer des magasins de mémoire ; les ressources `file` et `github_repository` nécessitent un environnement cloud. Le formulaire de déploiement de la Claude Console ne propose actuellement pas de magasins de mémoire pour les environnements auto-hébergés ; associez-les plutôt via l'API ou un SDK.
* Les déploiements nécessitent également au moins un événement initial, un `user.message` ou un `user.define_outcome`, qui lance le travail de chaque session. Dans un fichier de déploiement pour `ant apply`, le texte situé sous le frontmatter devient ce `user.message`.
* Dans le `schedule` (csharp, go: `Schedule`), vous définissez une `expression` (csharp, go: `Expression`) cron et un `timezone` (csharp, go: `Timezone`). La granularité maximale prise en charge est la minute.
Sur [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), chaque exécution crée sa session en tant que rôle IAM dans votre compte AWS. Avant de créer le déploiement, définissez le champ `execution_identity` de l'agent sur `{"type": "aws_role", "role_arn": "arn:aws:iam::123456789012:role/example-role"}`. La création d'un déploiement pour un agent sans ce champ renvoie une erreur 400.
* **Politique d'approbation :** autorisez le principal de service `aws-external-anthropic.amazonaws.com` à appeler `sts:AssumeRole` et `sts:SetSourceIdentity`.
* **Autorisations du rôle :** autorisez `aws-external-anthropic:CreateSession`, `sts:GetWebIdentityToken` et `sts:TagGetWebIdentityToken`.
* **Autorisations de l'appelant :** le principal IAM qui définit le rôle sur l'agent a besoin de `iam:PassRole` sur ce rôle. Le rôle doit se trouver dans le même compte AWS. Aucune [politique gérée](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#managed-policies) n'accorde `iam:PassRole`.
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/deployments?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"name": "Weekly compliance scan",
"agent": "'"$AGENT_ID"'",
"environment_id": "'"$ENVIRONMENT_ID"'",
"initial_events": [
{"type": "user.message", "content": [{"type": "text", "text": "Run the weekly compliance scan."}]}
],
"schedule": {
"type": "cron",
"expression": "0 20 * * 5",
"timezone": "America/New_York"
}
}'
```
```bash CLI
ant apply deployment.md
```
```markdown
---
name: Weekly compliance scan
agent: agent_011CYm1BLqPXpQRk5khsSXrs
environment_id: env_01595EKxaaTTGwwY3kyXdtbs
schedule:
type: cron
expression: "0 20 * * 5"
timezone: America/New_York
---
Run the weekly compliance scan.
```
[`ant apply`](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/apply) affiche l'ID du nouveau déploiement et l'enregistre dans `claude-lock.json`. Pour voir l'objet de déploiement, exécutez `ant beta:deployments retrieve`.
```python Python
deployment = client.beta.deployments.create(
name="Weekly compliance scan",
agent=agent.id,
environment_id=environment.id,
initial_events=[
{
"type": "user.message",
"content": [{"type": "text", "text": "Run the weekly compliance scan."}],
},
],
schedule={
"type": "cron",
"expression": "0 20 * * 5",
"timezone": "America/New_York",
},
)
```
```typescript TypeScript
const deployment = await client.beta.deployments.create({
name: "Weekly compliance scan",
agent: agent.id,
environment_id: environment.id,
initial_events: [
{
type: "user.message",
content: [{ type: "text", text: "Run the weekly compliance scan." }]
}
],
schedule: {
type: "cron",
expression: "0 20 * * 5",
timezone: "America/New_York"
}
});
```
```csharp C#
var deployment = await client.Beta.Deployments.Create(new()
{
Name = "Weekly compliance scan",
Agent = agent.ID,
EnvironmentID = environment.ID,
InitialEvents =
[
new BetaManagedAgentsUserMessageEventParams
{
Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
Content =
[
new BetaManagedAgentsTextBlock
{
Type = BetaManagedAgentsTextBlockType.Text,
Text = "Run the weekly compliance scan.",
},
],
},
],
Schedule = new BetaManagedAgentsScheduleParams
{
Type = BetaManagedAgentsScheduleParamsType.Cron,
Expression = "0 20 * * 5",
Timezone = "America/New_York",
},
});
```
```go Go
deployment, err := client.Beta.Deployments.New(ctx, anthropic.BetaDeploymentNewParams{
Name: "Weekly compliance scan",
Agent: anthropic.BetaDeploymentNewParamsAgentUnion{OfString: anthropic.String(agent.ID)},
EnvironmentID: environment.ID,
InitialEvents: []anthropic.BetaManagedAgentsDeploymentInitialEventParamsUnion{{
OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
OfText: &anthropic.BetaManagedAgentsTextBlockParam{
Type: anthropic.BetaManagedAgentsTextBlockTypeText,
Text: "Run the weekly compliance scan.",
},
}},
},
}},
Schedule: anthropic.BetaManagedAgentsScheduleParams{
Type: anthropic.BetaManagedAgentsScheduleParamsTypeCron,
Expression: "0 20 * * 5",
Timezone: "America/New_York",
},
})
if err != nil {
panic(err)
}
```
```java Java
var deployment = client.beta().deployments().create(
DeploymentCreateParams.builder()
.name("Weekly compliance scan")
.agent(agent.id())
.environmentId(environment.id())
.addInitialEvent(
BetaManagedAgentsUserMessageEventParams.builder()
.type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
.addTextContent("Run the weekly compliance scan.")
.build()
)
.schedule(
BetaManagedAgentsScheduleParams.builder()
.type(BetaManagedAgentsScheduleParams.Type.CRON)
.expression("0 20 * * 5")
.timezone("America/New_York")
.build()
)
.build()
);
```
```php PHP
$deployment = $client->beta->deployments->create(
name: 'Weekly compliance scan',
agent: $agent->id,
environmentID: $environment->id,
initialEvents: [
[
'type' => 'user.message',
'content' => [['type' => 'text', 'text' => 'Run the weekly compliance scan.']],
],
],
schedule: [
'type' => 'cron',
'expression' => '0 20 * * 5',
'timezone' => 'America/New_York',
],
);
```
```ruby Ruby
deployment = client.beta.deployments.create(
name: "Weekly compliance scan",
agent: agent.id,
environment_id: environment.id,
initial_events: [
{
type: "user.message",
content: [{type: "text", text: "Run the weekly compliance scan."}]
}
],
schedule: {
type: "cron",
expression: "0 20 * * 5",
timezone: "America/New_York"
}
)
```
La réponse inclut un objet de déploiement dont le champ `schedule.upcoming_runs_at` est renseigné avec les prochaines heures de déclenchement, afin de confirmer que votre planification a été correctement définie.
```json
{
"id": "depl_01xyz",
"status": "active",
"paused_reason": null,
"schedule": {
"type": "cron",
"expression": "0 20 * * 5",
"timezone": "America/New_York",
"last_run_at": null,
"upcoming_runs_at": [
"2026-05-09T00:00:00Z",
"2026-05-16T00:00:00Z",
"2026-05-23T00:00:00Z"
]
}
}
```
Les horodatages des prochaines exécutions reflètent exactement la planification configurée. Cependant, pour répartir la charge, l'exécution réelle applique un « jitter » (décalage aléatoire) pouvant atteindre 15 % de l'intervalle entre les exécutions, avec un minimum de 5 secondes et un maximum de 9 minutes.
Un maximum de **1 000 déploiements planifiés** est pris en charge par organisation. Contactez le support Anthropic si vous avez besoin de davantage.
Consultez la [référence Create Deployment](https://platform.claude.com/docs/fr/api/beta/deployments/create) pour l'ensemble des paramètres et le schéma de réponse.
### Sémantique du cron et du fuseau horaire
* **Expression :** cron POSIX standard (`minute hour day-of-month month day-of-week`). Vous pouvez générer et valider ces expressions cron dans la [Claude Console](https://platform.claude.com/workspaces/default/deployments).
* **Fuseau horaire :** identifiant de fuseau horaire IANA (par exemple, `"America/Los_Angeles"`).
* **Heure d'été :** les planifications cron utilisent une correspondance littérale avec l'heure locale, de sorte que `"0 20 * * *"` dans `America/New_York` se déclenche à 20 h 00 heure locale, que l'heure EST ou EDT soit en vigueur.
Les heures locales qui n'existent pas le jour du passage à l'heure d'été (comme 2 h du matin) ne sont pas déclenchées. Les heures locales qui se produisent deux fois le jour du retour à l'heure d'hiver se déclenchent deux fois. Planifiez en dehors de la plage de 1 h à 3 h heure locale, ou utilisez UTC, lorsque des exécutions manquées ou en double sont inacceptables.
### Définir un budget pour chaque exécution
Transmettez l'objet facultatif `budget` (csharp, go: `Budget`) lorsque vous créez ou mettez à jour le déploiement. Il a la même forme qu'un [budget de session](https://platform.claude.com/docs/fr/managed-agents/budgets). Le déploiement copie le plafond sur chaque session qu'il démarre, de sorte que le budget limite chaque exécution séparément plutôt que d'agir comme un plafond cumulatif sur l'ensemble des exécutions : un déploiement avec un plafond de `"2000"` peut dépenser jusqu'à environ 20 $ à chaque exécution.
Une session démarrée par le déploiement se comporte exactement comme toute autre session dotée d'un budget : elle se met en pause avec `budget_reached` lorsque son propre coût catalogue [atteint le plafond](https://platform.claude.com/docs/fr/managed-agents/budgets#when-a-session-reaches-its-budget). La modification du budget du déploiement s'applique aux exécutions démarrées ensuite ; une session déjà en cours conserve le plafond avec lequel elle a démarré, que vous pouvez [modifier via la session elle-même](https://platform.claude.com/docs/fr/managed-agents/session-operations#updating-the-session-budget). Contrairement à un budget de session, le budget d'un déploiement peut être supprimé avec `"budget": null` (python: `budget=None`; typescript: `budget: null`; ruby: `budget: nil`; go: `Budget: param.NullStruct[anthropic.BetaManagedAgentsBudgetLimitParam]()`; java: `.budget(Optional.empty())`; csharp: `Budget = null`; php: `requestOptions: ['extraBodyParams' => ['budget' => null]]`; cli: `--budget null`) puis redéfini ultérieurement.
L'exemple suivant définit un budget sur un déploiement existant :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-d '{
"budget": {
"type": "limit",
"max_list_cost": {"amount": "2000", "currency": "USD"}
}
}'
```
```bash CLI
ant apply deployment.md
```
```markdown
---
name: Weekly compliance scan
agent: agent_011CYm1BLqPXpQRk5khsSXrs
environment_id: env_01595EKxaaTTGwwY3kyXdtbs
schedule:
type: cron
expression: "0 20 * * 5"
timezone: America/New_York
budget:
type: limit
max_list_cost:
amount: "2000"
currency: USD
---
Run the weekly compliance scan.
```
```python Python
updated_deployment = client.beta.deployments.update(
deployment.id,
budget={
"type": "limit",
"max_list_cost": {"amount": "2000", "currency": "USD"},
},
)
print(updated_deployment.budget.max_list_cost.amount) # 2000
```
```typescript TypeScript
const updatedDeployment = await client.beta.deployments.update(deployment.id, {
budget: {
type: "limit",
max_list_cost: { amount: "2000", currency: "USD" }
}
});
console.log(updatedDeployment.budget?.max_list_cost.amount); // 2000
```
```csharp C#
var updatedDeployment = await client.Beta.Deployments.Update(deployment.ID, new()
{
Budget = new()
{
Type = BetaManagedAgentsBudgetLimitType.Limit,
MaxListCost = new() { Amount = "2000", Currency = BetaCurrency.Usd },
},
});
Console.WriteLine(updatedDeployment.Budget?.MaxListCost.Amount); // 2000
```
```go Go
updatedDeployment, err := client.Beta.Deployments.Update(ctx, deployment.ID, anthropic.BetaDeploymentUpdateParams{
Budget: anthropic.BetaManagedAgentsBudgetLimitParam{
Type: anthropic.BetaManagedAgentsBudgetLimitTypeLimit,
MaxListCost: anthropic.BetaMonetaryAmountParam{
Amount: "2000",
Currency: anthropic.BetaCurrencyUsd,
},
},
})
if err != nil {
panic(err)
}
fmt.Println(updatedDeployment.Budget.MaxListCost.Amount) // 2000
```
```java Java
var updatedDeployment = client.beta().deployments().update(
deployment.id(),
DeploymentUpdateParams.builder()
.budget(BetaManagedAgentsBudgetLimit.builder()
.type(BetaManagedAgentsBudgetLimit.Type.LIMIT)
.maxListCost(BetaMonetaryAmount.builder()
.amount("2000")
.currency(BetaCurrency.USD)
.build())
.build())
.build()
);
IO.println(updatedDeployment.budget().orElseThrow().maxListCost().amount()); // 2000
```
```php PHP
$updatedDeployment = $client->beta->deployments->update(
$deployment->id,
budget: [
'type' => 'limit',
'max_list_cost' => ['amount' => '2000', 'currency' => 'USD'],
],
);
echo "{$updatedDeployment->budget->maxListCost->amount}\n"; // 2000
```
```ruby Ruby
updated_deployment = client.beta.deployments.update(
deployment.id,
budget: {
type: "limit",
max_list_cost: {amount: "2000", currency: "USD"}
}
)
puts updated_deployment.budget.max_list_cost.amount # 2000
```
## Exécutions de déploiement
Les déploiements peuvent ne pas se déclencher pour diverses raisons : par exemple, si la ressource `environment` a été archivée, ou si la création de session est soumise à une « rate limit » (limite de débit). Chaque tentative d'exécution d'un déploiement génère un enregistrement de « **deployment run** » (**exécution de déploiement**), ce qui vous permet de suivre les réussites et les échecs indépendamment du cycle de vie de la session.
Les déploiements réussis génèrent des sessions actives, et une exécution de déploiement réussie contient le `session_id` (java: `sessionId`; php: `sessionID`; csharp, go: `SessionID`) associé. Pour suivre le cycle de vie d'une session, suivez les événements de session via le [flux d'événements](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming) ou les [webhooks](https://platform.claude.com/docs/fr/managed-agents/webhooks). Les changements de cycle de vie des déploiements et le résultat de chaque exécution planifiée sont également transmis sous forme d'événements webhook, répertoriés dans les onglets Deployment events et Deployment run events de [Types d'événements pris en charge](https://platform.claude.com/docs/fr/managed-agents/webhooks#supported-event-types).
Listez toutes les exécutions d'un déploiement comme suit :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/deployment_runs?beta=true&deployment_id=$DEPLOYMENT_ID" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployment-runs list --deployment-id "$DEPLOYMENT_ID"
```
```python Python
for run in client.beta.deployment_runs.list(
deployment_id=deployment.id,
):
print(run.created_at, run.session_id or run.error.type)
```
```typescript TypeScript
for await (const run of client.beta.deploymentRuns.list({
deployment_id: deployment.id
})) {
console.log(run.created_at, run.session_id ?? run.error?.type);
}
```
```csharp C#
var runs = await client.Beta.DeploymentRuns.List(
new() { DeploymentID = deployment.ID }
);
await foreach (var run in runs.Paginate())
{
// L'union Error expose .Message directement ; le discriminateur est lu
// depuis .Json jusqu'à ce qu'un accesseur commun .Type soit ajouté.
var outcome = run.SessionID ?? run.Error!.Json.GetProperty("type").GetString();
Console.WriteLine($"{run.CreatedAt} {outcome}");
}
```
```go Go
runs := client.Beta.DeploymentRuns.ListAutoPaging(ctx, anthropic.BetaDeploymentRunListParams{
DeploymentID: anthropic.String(deployment.ID),
})
for runs.Next() {
run := runs.Current()
if run.SessionID != "" {
fmt.Println(run.CreatedAt.Format(time.RFC3339), run.SessionID)
} else {
fmt.Println(run.CreatedAt.Format(time.RFC3339), run.Error.Type)
}
}
if err := runs.Err(); err != nil {
panic(err)
}
```
```java Java
for (var run : client.beta().deploymentRuns().list(
DeploymentRunListParams.builder()
.deploymentId(deployment.id())
.build()).autoPager()) {
// L'union Error n'expose pas encore les accesseurs communs .type()/.message() ;
// .toString() inclut les deux.
IO.println(run.createdAt() + " "
+ run.sessionId().orElseGet(() -> run.error().orElseThrow().toString()));
}
```
```php PHP
foreach ($client->beta->deploymentRuns->list(
deploymentID: $deployment->id,
)->pagingEachItem() as $run) {
$outcome = $run->sessionID ?? $run->error->type;
echo "{$run->createdAt->format(DATE_ATOM)} {$outcome}\n";
}
```
```ruby Ruby
client.beta.deployment_runs.list(
deployment_id: deployment.id
).auto_paging_each do
puts "#{it.created_at} #{it.session_id || it.error.type}"
end
```
Vous pouvez en outre filtrer les exécutions de déploiement comportant des erreurs :
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/deployment_runs?beta=true&deployment_id=$DEPLOYMENT_ID&has_error=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployment-runs list --deployment-id "$DEPLOYMENT_ID" --has-error
```
```python Python
for run in client.beta.deployment_runs.list(
deployment_id=deployment.id,
has_error=True,
):
print(run.created_at, run.error.type, run.error.message)
```
```typescript TypeScript
for await (const run of client.beta.deploymentRuns.list({
deployment_id: deployment.id,
has_error: true
})) {
console.log(run.created_at, run.error?.type, run.error?.message);
}
```
```csharp C#
var failedRuns = await client.Beta.DeploymentRuns.List(
new() { DeploymentID = deployment.ID, HasError = true }
);
await foreach (var failedRun in failedRuns.Paginate())
{
var error = failedRun.Error!;
var errorType = error.Json.GetProperty("type").GetString();
Console.WriteLine($"{failedRun.CreatedAt} {errorType} {error.Message}");
}
```
```go Go
failedRuns := client.Beta.DeploymentRuns.ListAutoPaging(ctx, anthropic.BetaDeploymentRunListParams{
DeploymentID: anthropic.String(deployment.ID),
HasError: anthropic.Bool(true),
})
for failedRuns.Next() {
failedRun := failedRuns.Current()
fmt.Println(failedRun.CreatedAt.Format(time.RFC3339), failedRun.Error.Type, failedRun.Error.Message)
}
if err := failedRuns.Err(); err != nil {
panic(err)
}
```
```java Java
for (var run : client.beta().deploymentRuns().list(
DeploymentRunListParams.builder()
.deploymentId(deployment.id())
.hasError(true)
.build()).autoPager()) {
IO.println(run.createdAt() + " " + run.error().orElseThrow());
}
```
```php PHP
foreach ($client->beta->deploymentRuns->list(
deploymentID: $deployment->id,
hasError: true,
)->pagingEachItem() as $run) {
echo "{$run->createdAt->format(DATE_ATOM)} {$run->error->type} {$run->error->message}\n";
}
```
```ruby Ruby
client.beta.deployment_runs.list(
deployment_id: deployment.id,
has_error: true
).auto_paging_each do
puts "#{it.created_at} #{it.error.type} #{it.error.message}"
end
```
Une exécution échouée inclut un `error` avec un `type` décrivant la raison pour laquelle la création de session a été rejetée (par exemple, `environment_archived_error`, `agent_archived_error` ou `session_rate_limited_error`). Consultez la [référence List Deployment Runs](https://platform.claude.com/docs/fr/api/beta/deployment_runs/list) pour tous les paramètres de filtre et le schéma de réponse.
```json
{
"type": "deployment_run",
"id": "drun_01abc124",
"deployment_id": "depl_01xyz",
"trigger_context": { "type": "schedule", "scheduled_at": "2026-05-09T00:00:00Z" },
"session_id": null,
"error": {
"type": "environment_archived_error",
"message": "environment `env_01abc` is archived"
},
"agent": { "type": "agent", "id": "agent_01ghi789", "version": 3 },
"created_at": "2026-05-09T00:00:01Z"
}
```
Pour récupérer une seule exécution par son ID, appelez [`GET /v1/deployment_runs/{deployment_run_id}`](https://platform.claude.com/docs/fr/api/beta/deployment_runs/retrieve). Un [événement webhook `deployment_run`](https://platform.claude.com/docs/fr/managed-agents/webhooks#supported-event-types) transporte l'ID de l'exécution dans son `data.id`.
## Gérer le cycle de vie d'un déploiement
Chaque changement de cycle de vie émet un [événement webhook](https://platform.claude.com/docs/fr/managed-agents/webhooks#supported-event-types), ce qui vous permet de réagir à un déploiement mis en pause, réactivé ou archivé sans interrogation périodique ; consultez l'onglet Deployment events.
**Pause** suspend les déclenchements planifiés à partir de ce moment ; les sessions en cours issues d'une exécution de déploiement antérieure continuent de s'exécuter. Les exécutions manuelles via le point de terminaison `run` restent autorisées pendant la pause. La mise en pause définit `paused_reason` sur `{"type": "manual"}` ; la réactivation l'efface.
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID/pause?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployments pause --deployment-id "$DEPLOYMENT_ID"
```
```python Python
client.beta.deployments.pause(deployment.id)
```
```typescript TypeScript
await client.beta.deployments.pause(deployment.id);
```
```csharp C#
await client.Beta.Deployments.Pause(deployment.ID);
```
```go Go
if _, err := client.Beta.Deployments.Pause(ctx, deployment.ID, anthropic.BetaDeploymentPauseParams{}); err != nil {
panic(err)
}
```
```java Java
client.beta().deployments().pause(deployment.id());
```
```php PHP
$client->beta->deployments->pause($deployment->id);
```
```ruby Ruby
client.beta.deployments.pause(deployment.id)
```
**Unpause** reprend la planification à partir de la prochaine occurrence planifiée. Les déclenchements manqués ne sont pas rattrapés.
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID/unpause?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployments unpause --deployment-id "$DEPLOYMENT_ID"
```
```python Python
client.beta.deployments.unpause(deployment.id)
```
```typescript TypeScript
await client.beta.deployments.unpause(deployment.id);
```
```csharp C#
await client.Beta.Deployments.Unpause(deployment.ID);
```
```go Go
if _, err := client.Beta.Deployments.Unpause(ctx, deployment.ID, anthropic.BetaDeploymentUnpauseParams{}); err != nil {
panic(err)
}
```
```java Java
client.beta().deployments().unpause(deployment.id());
```
```php PHP
$client->beta->deployments->unpause($deployment->id);
```
```ruby Ruby
client.beta.deployments.unpause(deployment.id)
```
**Archive**, contrairement à **pause**, est définitif : la planification prend fin et le déploiement ne peut plus être modifié.
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID/archive?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployments archive --deployment-id "$DEPLOYMENT_ID"
```
```python Python
client.beta.deployments.archive(deployment.id)
```
```typescript TypeScript
await client.beta.deployments.archive(deployment.id);
```
```csharp C#
await client.Beta.Deployments.Archive(deployment.ID);
```
```go Go
if _, err := client.Beta.Deployments.Archive(ctx, deployment.ID, anthropic.BetaDeploymentArchiveParams{}); err != nil {
panic(err)
}
```
```java Java
client.beta().deployments().archive(deployment.id());
```
```php PHP
$client->beta->deployments->archive($deployment->id);
```
```ruby Ruby
client.beta.deployments.archive(deployment.id)
```
### Comportement en cas d'échec
Les réponses de limite de débit lors de la création de session sont immédiatement enregistrées comme une exécution `session_rate_limited_error` sans nouvelle tentative ; la planification réessaie à la prochaine occurrence planifiée. Les limites de débit sur les appels API sous-jacents au sein d'une session sont gérées par la session elle-même.
Si l'agent d'un déploiement a été archivé, le déploiement est automatiquement archivé dans la même opération. Si l'agent a été supprimé, le prochain déclenchement planifié détecte l'agent manquant et archive automatiquement le déploiement. Dans les deux cas, aucune exécution de déploiement n'est enregistrée. Si un sous-agent référencé par l'agent a été archivé, le prochain déclenchement enregistre une exécution échouée avec `error.type: "agent_archived_error"` et le déploiement est automatiquement mis en pause afin que vous puissiez mettre à jour l'agent et reprendre. Les autres erreurs irrécupérables de création de session, comme un environnement ou un coffre archivé, se comportent de la même manière : le déclenchement enregistre une exécution échouée et le déploiement est automatiquement mis en pause. Le `paused_reason.error.type` du déploiement reflète le `error.type` de l'exécution échouée.
## Déclencher une exécution manuelle
Pour exécuter un déploiement en dehors de sa planification, appelez le [point de terminaison `run`](https://platform.claude.com/docs/fr/api/beta/deployments/run). Cela crée immédiatement une session et écrit une exécution de déploiement avec `trigger_context.type: "manual"`. Cela vous permet de tester un déploiement avant de vous engager sur la planification.
```bash cURL
curl --fail-with-body -sS -X POST "https://api.anthropic.com/v1/deployments/$DEPLOYMENT_ID/run?beta=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01"
```
```bash CLI
ant beta:deployments run --deployment-id "$DEPLOYMENT_ID"
```
```python Python
run = client.beta.deployments.run(deployment.id)
```
```typescript TypeScript
const run = await client.beta.deployments.run(deployment.id);
```
```csharp C#
var manualRun = await client.Beta.Deployments.Run(deployment.ID);
```
```go Go
manualRun, err := client.Beta.Deployments.Run(ctx, deployment.ID, anthropic.BetaDeploymentRunParams{})
if err != nil {
panic(err)
}
```
```java Java
var run = client.beta().deployments().run(deployment.id());
```
```php PHP
$run = $client->beta->deployments->run($deployment->id);
```
```ruby Ruby
run = client.beta.deployments.run(deployment.id)
```