> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cdp.coinbase.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Pause and Resume Policies

> Pause enforcement of a wallet policy without deleting its rules, then resume it manually or at a scheduled time.

Pausing a policy skips its rules during evaluation. Resuming it enforces the same rules again. The policy keeps its ID, scope, rules, and account assignments.

Use pause and resume to:

* Stop enforcing a policy until you explicitly resume it.
* Schedule enforcement to resume automatically after a temporary pause.

> [!WARNING]
>
> Pausing a policy removes its restrictions while the pause is in effect. It does not freeze the wallet or block signing. If no remaining active policy has rules targeting an operation, that operation is accepted by default.

## Pause a policy

Choose an existing policy's ID. The pause applies to every account governed by that policy:

| Scope | Effect |
| - | - |
| `project` | Skips the project policy for all accounts it governs, including end-user operations. Active account policies are still evaluated where applicable |
| `account` | Skips the policy for every account assigned to it. The project policy keeps its normal precedence |

User wallets support project-scope policies only.

Other applicable policies continue to follow the normal [evaluation rules](/wallets/security-and-policies/policy-engine/overview.md#evaluation). Pausing one policy does not pause the others.

Use a secret API key from the policy's project with the **Non-custodial > Manage (modify policies)** scope enabled. These requests do not require a wallet secret.

The SDKs read `CDP_API_KEY_ID` and `CDP_API_KEY_SECRET` from your environment. For the CLI, map those exported credentials to its [environment variables](/ai-agents/cdp-for-agents/cdp-mcp.md#headless--environment-variable-configuration) once:

```bash theme={null}
export CDP_KEY_ID="$CDP_API_KEY_ID"
export CDP_KEY_SECRET="$CDP_API_KEY_SECRET"
```

### Pause until you resume

Omit the resume deadline to pause until you explicitly resume the policy.

**Node (TypeScript)**

```typescript theme={null}
import { CdpClient } from "@coinbase/cdp-sdk";

const cdp = new CdpClient();
const policy = await cdp.policies.pausePolicy({ id: "YOUR_POLICY_ID" });

console.log(policy.status);
```

**Python**

```python theme={null}
from cdp import CdpClient

async with CdpClient() as cdp:
    policy = await cdp.policies.pause_policy(id="YOUR_POLICY_ID")
    print(policy.status)
```

**CDP CLI**

```bash theme={null}
POLICY_ID="YOUR_POLICY_ID"

cdp api -X POST "/policy-engine/policies/${POLICY_ID}/pause" -e live
```

### Resume automatically

Set a resume deadline in the future, at most 30 days from the request.

**Node (TypeScript)**

```typescript theme={null}
import { CdpClient } from "@coinbase/cdp-sdk";

const cdp = new CdpClient();
const policy = await cdp.policies.pausePolicy({
  id: "YOUR_POLICY_ID",
  resumeAt: new Date(Date.now() + 60 * 60 * 1000),
});

console.log(policy.status, policy.resumeAt);
```

**Python**

```python theme={null}
from datetime import datetime, timedelta, timezone

from cdp import CdpClient

async with CdpClient() as cdp:
    policy = await cdp.policies.pause_policy(
        id="YOUR_POLICY_ID",
        resume_at=datetime.now(timezone.utc) + timedelta(hours=1),
    )
    print(policy.status, policy.resume_at)
```

**CDP CLI**

Replace the example timestamp with your desired future deadline.

```bash theme={null}
POLICY_ID="YOUR_POLICY_ID"

cdp api -X POST "/policy-engine/policies/${POLICY_ID}/pause" -e live \
  resumeAt="2026-10-23T20:00:00Z"
```

## Resume a policy

Resume enforcement before the deadline, or clear an indefinite pause:

**Node (TypeScript)**

```typescript theme={null}
import { CdpClient } from "@coinbase/cdp-sdk";

const cdp = new CdpClient();
const policy = await cdp.policies.resumePolicy({ id: "YOUR_POLICY_ID" });

console.log(policy.status);
```

**Python**

```python theme={null}
from cdp import CdpClient

async with CdpClient() as cdp:
    policy = await cdp.policies.resume_policy(id="YOUR_POLICY_ID")
    print(policy.status)
```

**CDP CLI**

```bash theme={null}
POLICY_ID="YOUR_POLICY_ID"

cdp api -X POST "/policy-engine/policies/${POLICY_ID}/resume" -e live
```

If you set `resumeAt`, the policy is evaluated again once the deadline passes, without a separate resume request.

## Read the result

Pause and resume both return `200` with the policy object. The SDKs return a `Policy`; the CLI prints the JSON response. Python uses `paused_at` and `resume_at` for the corresponding JSON fields.

| Field | Description |
| - | - |
| `status` | `paused` when the policy is skipped during evaluation, or `active` when it is enforced |
| `pausedAt` | When the current pause began. Present only while the policy is paused |
| `resumeAt` | When enforcement resumes automatically. Present only while the policy is paused with a deadline |

An active response omits `pausedAt` and `resumeAt`, including after an automatic resume. Get and list responses report the same effective state.

For example, this policy is paused for one hour:

```json theme={null}
{
  "id": "123e4567-e89b-12d3-a456-426614174000",
  "description": "Account Allowlist Example",
  "scope": "account",
  "status": "paused",
  "pausedAt": "2026-10-16T15:00:00Z",
  "resumeAt": "2026-10-16T16:00:00Z",
  "rules": [
    {
      "action": "accept",
      "operation": "signEvmTransaction",
      "criteria": [{ "type": "evmAddress", "addresses": ["0x000000000000000000000000000000000000dEaD"], "operator": "in" }]
    }
  ],
  "createdAt": "2026-10-15T12:00:00Z",
  "updatedAt": "2026-10-16T15:00:00Z"
}
```

### Repeated requests

| Request | Effect |
| - | - |
| Pause an already paused policy | Keeps the original `pausedAt` and replaces `resumeAt`. Omitting `resumeAt` removes the deadline |
| Pause an already paused policy with the same deadline | Leaves the policy unchanged |
| Resume an already active policy | Returns the policy unchanged |

## Errors

| Status | When |
| - | - |
| `400` | The request is invalid, such as a `resumeAt` that is not in the future or is more than 30 days away |
| `404` | The policy does not exist in your project, or policy pause is not available for your project (pause only) |
| `429` | The request exceeds the API rate limit |
| `503` | The service is temporarily unavailable. Retry the request |

## Limitations

* A pause applies to the whole policy. You cannot pause an individual rule or operation.
* Policy pause must be enabled for your project. You can still resume an existing pause if pause access is later disabled.

## What to read next

* [Policy Engine overview](/wallets/security-and-policies/policy-engine/overview.md): policy scope, API key permissions, and evaluation.
* [Test and debug policies](/wallets/security-and-policies/policy-engine/simulate-policies.md): check a sample operation against your current policies.
* [EVM policies](/wallets/security-and-policies/policy-engine/evm-policies.md): examples of EVM rules to review before resuming.
* [Solana policies](/wallets/security-and-policies/policy-engine/solana-policies.md): examples of Solana rules.