# API Tokens
Source: https://docs.apitraffic.io/api-reference/api-tokens

Manage API tokens for programmatic access to your ApiTraffic account

## List API Tokens

<api-endpoint method="GET" />

Retrieve all API tokens associated with an account.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="hasMore" type="boolean">
  Indicates if there are more records to paginate through
</ResponseField>

<ResponseField name="records" type="array">
  <Expandable title="API Token Objects">
    <ResponseField name="sid" type="string">
      Unique API token identifier
    </ResponseField>

    <ResponseField name="accountSid" type="string">
      Account identifier this token belongs to
    </ResponseField>

    <ResponseField name="name" type="string">
      Name of the API token
    </ResponseField>

    <ResponseField name="description" type="string">
      Description of the token's purpose
    </ResponseField>

    <ResponseField name="scopes" type="array">
      Array of permission scopes granted to this token
    </ResponseField>

    <ResponseField name="lastUsedAt" type="string">
      ISO 8601 timestamp of last token usage (nullable)
    </ResponseField>

    <ResponseField name="expiresAt" type="string">
      ISO 8601 timestamp when token expires (nullable for no expiration)
    </ResponseField>

    <ResponseField name="isActive" type="boolean">
      Whether this token is currently active
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp of token creation
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const tokens = await response.json();
  console.log(tokens);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens',
      headers={'Authorization': 'Bearer your-jwt-token'}
  )

  tokens = response.json()
  print(tokens)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "hasMore": false,
    "records": [
      {
        "sid": "tok_abc123def456ghi789jkl012",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "name": "Production API Token",
        "description": "Token for production monitoring integration",
        "scopes": ["buckets:read", "requests:read", "metrics:read"],
        "lastUsedAt": "2023-12-01T14:30:00.000Z",
        "expiresAt": "2024-12-01T00:00:00.000Z",
        "isActive": true,
        "createdAt": "2023-12-01T10:30:00.000Z"
      },
      {
        "sid": "tok_xyz789uvw012rst345abc",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "name": "CI/CD Token",
        "description": "Token for automated testing and deployment",
        "scopes": ["buckets:read", "buckets:write"],
        "lastUsedAt": null,
        "expiresAt": null,
        "isActive": true,
        "createdAt": "2023-11-15T09:15:00.000Z"
      }
    ]
  }
  ```
</ResponseExample>

***

## Get API Token

<api-endpoint method="GET" />

Retrieve details of a specific API token.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  API token identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

Returns a single API token object with the same structure as described in the List API Tokens response.

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens/tok_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens/tok_abc123def456ghi789jkl012', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const token = await response.json();
  console.log(token);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "tok_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Production API Token",
    "description": "Token for production monitoring integration",
    "scopes": ["buckets:read", "requests:read", "metrics:read"],
    "lastUsedAt": "2023-12-01T14:30:00.000Z",
    "expiresAt": "2024-12-01T00:00:00.000Z",
    "isActive": true,
    "createdAt": "2023-12-01T10:30:00.000Z"
  }
  ```
</ResponseExample>

***

## Create API Token

<api-endpoint method="POST" />

Create a new API token for programmatic access.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Name of the API token
</ParamField>

<ParamField type="string">
  Description of the token's purpose
</ParamField>

<ParamField type="array">
  Array of permission scopes to grant to this token
</ParamField>

<ParamField type="string">
  ISO 8601 timestamp when token should expire (optional, null for no expiration)
</ParamField>

### Response

<ResponseField name="sid" type="string">
  Unique API token identifier
</ResponseField>

<ResponseField name="token" type="string">
  The actual API token value (only returned on creation)
</ResponseField>

<ResponseField name="accountSid" type="string">
  Account identifier
</ResponseField>

<ResponseField name="name" type="string">
  Name of the API token
</ResponseField>

<ResponseField name="description" type="string">
  Description of the token
</ResponseField>

<ResponseField name="scopes" type="array">
  Array of granted permission scopes
</ResponseField>

<ResponseField name="expiresAt" type="string">
  Expiration timestamp (nullable)
</ResponseField>

<ResponseField name="isActive" type="boolean">
  Whether the token is active
</ResponseField>

<ResponseField name="createdAt" type="string">
  ISO 8601 timestamp of creation
</ResponseField>

<Warning>
  The token value is only returned once during creation. Store it securely as it cannot be retrieved again.
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Analytics Token",
      "description": "Token for analytics dashboard integration",
      "scopes": ["metrics:read", "buckets:read"],
      "expiresAt": "2024-12-31T23:59:59.000Z"
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Analytics Token',
      description: 'Token for analytics dashboard integration',
      scopes: ['metrics:read', 'buckets:read'],
      expiresAt: '2024-12-31T23:59:59.000Z'
    })
  });

  const token = await response.json();
  console.log(token);
  // Store token.token securely!
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens',
      headers={
          'Authorization': 'Bearer your-jwt-token',
          'Content-Type': 'application/json'
      },
      json={
          'name': 'Analytics Token',
          'description': 'Token for analytics dashboard integration',
          'scopes': ['metrics:read', 'buckets:read'],
          'expiresAt': '2024-12-31T23:59:59.000Z'
      }
  )

  token = response.json()
  print(token)
  # Store token['token'] securely!
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "tok_new789uvw012rst345def",
    "token": "at_live_1234567890abcdef...",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Analytics Token",
    "description": "Token for analytics dashboard integration",
    "scopes": ["metrics:read", "buckets:read"],
    "expiresAt": "2024-12-31T23:59:59.000Z",
    "isActive": true,
    "createdAt": "2023-12-01T15:45:00.000Z"
  }
  ```
</ResponseExample>

***

## Update API Token

<api-endpoint method="PUT" />

Update an existing API token's metadata.

<Info>
  You cannot update the token value itself or its scopes. To change scopes, create a new token and delete the old one.
</Info>

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  API token identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Name of the API token
</ParamField>

<ParamField type="string">
  Description of the token's purpose
</ParamField>

<ParamField type="boolean">
  Whether this token should be active
</ParamField>

### Response

Returns the updated API token object (without the token value).

<RequestExample>
  ```bash cURL theme={null}
  curl -X PUT "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens/tok_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Updated Production Token",
      "description": "Updated description for production monitoring",
      "isActive": false
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens/tok_abc123def456ghi789jkl012', {
    method: 'PUT',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Updated Production Token',
      description: 'Updated description for production monitoring',
      isActive: false
    })
  });

  const token = await response.json();
  console.log(token);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "tok_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Updated Production Token",
    "description": "Updated description for production monitoring",
    "scopes": ["buckets:read", "requests:read", "metrics:read"],
    "lastUsedAt": "2023-12-01T14:30:00.000Z",
    "expiresAt": "2024-12-01T00:00:00.000Z",
    "isActive": false,
    "createdAt": "2023-12-01T10:30:00.000Z"
  }
  ```
</ResponseExample>

***

## Delete API Token

<api-endpoint method="DELETE" />

Delete an API token, immediately revoking access.

<Warning>
  This action is irreversible. Any applications using this token will immediately lose access.
</Warning>

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  API token identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="sid" type="string">
  ID of the deleted API token
</ResponseField>

<ResponseField name="deleted" type="boolean">
  Flag indicating the token was successfully deleted
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X DELETE "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens/tok_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/apiTokens/tok_abc123def456ghi789jkl012', {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const result = await response.json();
  console.log(result);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "tok_abc123def456ghi789jkl012",
    "deleted": true
  }
  ```
</ResponseExample>

***

## Available Scopes

API tokens can be granted specific scopes to limit their access:

### Bucket Scopes

* `buckets:read` - View bucket information
* `buckets:write` - Create and modify buckets
* `buckets:delete` - Delete buckets

### Request Scopes

* `requests:read` - View request data
* `requests:write` - Modify request metadata (notes, etc.)
* `requests:delete` - Delete individual requests

### Metrics Scopes

* `metrics:read` - Access analytics and metrics data

### Redaction Scopes

* `redactions:read` - View redaction rules
* `redactions:write` - Create and modify redaction rules
* `redactions:delete` - Delete redaction rules

### Exclusion Scopes

* `exclusions:read` - View exclusion rules
* `exclusions:write` - Create and modify exclusion rules
* `exclusions:delete` - Delete exclusion rules

### Workflow Scopes

* `workflows:read` - View workflow configurations
* `workflows:write` - Create and modify workflows
* `workflows:delete` - Delete workflows

### Token Management Scopes

* `tokens:read` - View API token information
* `tokens:write` - Create and modify API tokens
* `tokens:delete` - Delete API tokens

***

## Using API Tokens

Once created, use your API token in the `Authorization` header:

```bash theme={null}
curl -H "Authorization: Bearer at_live_1234567890abcdef..." \
  https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets
```

### Token Format

* **Live tokens**: `at_live_` followed by random characters
* **Test tokens**: `at_test_` followed by random characters

### Best Practices

1. **Principle of Least Privilege**: Only grant the minimum scopes required
2. **Regular Rotation**: Rotate tokens periodically for security
3. **Secure Storage**: Store tokens securely, never in plain text
4. **Monitor Usage**: Check `lastUsedAt` to identify unused tokens
5. **Set Expiration**: Use expiration dates for temporary access
6. **Environment Separation**: Use different tokens for different environments


# Authentication
Source: https://docs.apitraffic.io/api-reference/authentication

Authentication endpoints for user management and session handling

## Get User Profile

<api-endpoint method="GET" />

Returns the authenticated user's profile information including account details.

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="sid" type="string">
  User's unique identifier
</ResponseField>

<ResponseField name="firstName" type="string">
  User's first name
</ResponseField>

<ResponseField name="lastName" type="string">
  User's last name
</ResponseField>

<ResponseField name="email" type="string">
  User's email address
</ResponseField>

<ResponseField name="timezone" type="string">
  User's timezone setting
</ResponseField>

<ResponseField name="defaultAccountSid" type="string">
  Default account identifier
</ResponseField>

<ResponseField name="createdAt" type="string">
  ISO 8601 timestamp of user creation
</ResponseField>

<ResponseField name="accounts" type="array">
  Array of account objects the user has access to
</ResponseField>

<ResponseField name="chat" type="object">
  <Expandable title="Chat Configuration">
    <ResponseField name="userHash" type="string">
      Hash for secure chat integration
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/authentication/me" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/authentication/me', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const user = await response.json();
  console.log(user);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.apitraffic.io/v1/authentication/me',
      headers={'Authorization': 'Bearer your-jwt-token'}
  )

  user = response.json()
  print(user)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "usr_abc123def456ghi789",
    "firstName": "John",
    "lastName": "Doe", 
    "email": "john.doe@example.com",
    "timezone": "America/New_York",
    "defaultAccountSid": "acc_xyz789uvw012rst345",
    "createdAt": "2023-12-01T10:30:00.000Z",
    "accounts": [
      {
        "sid": "acc_xyz789uvw012rst345",
        "name": "My Company",
        "role": "owner"
      }
    ],
    "chat": {
      "userHash": "a1b2c3d4e5f6g7h8i9j0"
    }
  }
  ```
</ResponseExample>

***

## Verify Token

<api-endpoint method="GET" />

Verifies the validity of an authentication token.

### Headers

<ParamField type="string">
  Bearer token to verify
</ParamField>

### Response

<ResponseField name="accountSid" type="string">
  Account identifier associated with the token
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/authentication/verify" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/authentication/verify', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const verification = await response.json();
  console.log(verification);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "accountSid": "acc_xyz789uvw012rst345"
  }
  ```
</ResponseExample>

***

## Sign Out

<api-endpoint method="GET" />

Signs the user out of their current session.

### Headers

<ParamField type="string">
  Bearer token for the session to terminate
</ParamField>

### Response

<ResponseField name="success" type="boolean">
  Indicates if the sign out was successful
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/authentication/signout" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/authentication/signout', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const result = await response.json();
  console.log(result);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "success": true
  }
  ```
</ResponseExample>


# Buckets
Source: https://docs.apitraffic.io/api-reference/buckets

Manage buckets for organizing your API traffic data

## List Buckets

<api-endpoint method="GET" />

Retrieve all buckets associated with an account.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="hasMore" type="boolean">
  Indicates if there are more records to paginate through
</ResponseField>

<ResponseField name="records" type="array">
  <Expandable title="Bucket Objects">
    <ResponseField name="sid" type="string">
      Unique bucket identifier
    </ResponseField>

    <ResponseField name="accountSid" type="string">
      Account identifier this bucket belongs to
    </ResponseField>

    <ResponseField name="name" type="string">
      Name of the bucket
    </ResponseField>

    <ResponseField name="verifySslCerts" type="boolean">
      Whether SSL certificates should be verified as valid and trusted
    </ResponseField>

    <ResponseField name="appIsConnected" type="boolean">
      Whether the bucket is connected to an application via the SDK
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp of bucket creation
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const buckets = await response.json();
  console.log(buckets);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets',
      headers={'Authorization': 'Bearer your-jwt-token'}
  )

  buckets = response.json()
  print(buckets)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "hasMore": false,
    "records": [
      {
        "sid": "bkt_xyz789uvw012rst345abc",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "name": "Production API",
        "verifySslCerts": true,
        "appIsConnected": true,
        "createdAt": "2023-12-01T10:30:00.000Z"
      }
    ]
  }
  ```
</ResponseExample>

***

## Get Bucket

<api-endpoint method="GET" />

Retrieve details of a specific bucket.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Bucket identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="sid" type="string">
  Unique bucket identifier
</ResponseField>

<ResponseField name="accountSid" type="string">
  Account identifier this bucket belongs to
</ResponseField>

<ResponseField name="name" type="string">
  Name of the bucket
</ResponseField>

<ResponseField name="verifySslCerts" type="boolean">
  Whether SSL certificates should be verified as valid and trusted
</ResponseField>

<ResponseField name="appIsConnected" type="boolean">
  Whether the bucket is connected to an application via the SDK
</ResponseField>

<ResponseField name="createdAt" type="string">
  ISO 8601 timestamp of bucket creation
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const bucket = await response.json();
  console.log(bucket);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "bkt_xyz789uvw012rst345abc",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Production API",
    "verifySslCerts": true,
    "appIsConnected": true,
    "createdAt": "2023-12-01T10:30:00.000Z"
  }
  ```
</ResponseExample>

***

## Create Bucket

<api-endpoint method="POST" />

Create a new bucket for organizing API traffic data.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  The name of the bucket
</ParamField>

### Response

Returns the created bucket object with the same structure as the Get Bucket response.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Staging API"
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Staging API'
    })
  });

  const bucket = await response.json();
  console.log(bucket);
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets',
      headers={
          'Authorization': 'Bearer your-jwt-token',
          'Content-Type': 'application/json'
      },
      json={'name': 'Staging API'}
  )

  bucket = response.json()
  print(bucket)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "bkt_new789uvw012rst345def",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Staging API",
    "verifySslCerts": true,
    "appIsConnected": false,
    "createdAt": "2023-12-01T15:45:00.000Z"
  }
  ```
</ResponseExample>

***

## Update Bucket

<api-endpoint method="PUT" />

Update the details of an existing bucket.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Bucket identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  The name of the bucket
</ParamField>

<ParamField type="boolean">
  Whether SSL certificates should be verified as valid and trusted
</ParamField>

### Response

Returns the updated bucket object.

<RequestExample>
  ```bash cURL theme={null}
  curl -X PUT "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Updated Production API",
      "verifySslCerts": false
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc', {
    method: 'PUT',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Updated Production API',
      verifySslCerts: false
    })
  });

  const bucket = await response.json();
  console.log(bucket);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "bkt_xyz789uvw012rst345abc",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Updated Production API",
    "verifySslCerts": false,
    "appIsConnected": true,
    "createdAt": "2023-12-01T10:30:00.000Z"
  }
  ```
</ResponseExample>

***

## Delete Bucket

<api-endpoint method="DELETE" />

Delete a bucket and all associated requests.

<Warning>
  This action is irreversible. All data associated with the bucket will be permanently deleted.
</Warning>

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Bucket identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="sid" type="string">
  ID of the deleted bucket
</ResponseField>

<ResponseField name="deleted" type="boolean">
  Flag indicating the bucket was successfully deleted
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X DELETE "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc', {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const result = await response.json();
  console.log(result);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "bkt_xyz789uvw012rst345abc",
    "deleted": true
  }
  ```
</ResponseExample>

***

## Get SDK Settings

<api-endpoint method="GET" />

Retrieve SDK settings for a bucket based on the ingestion key.

### Path Parameters

<ParamField type="string">
  Bucket identifier
</ParamField>

### Query Parameters

<ParamField type="string">
  Where data should be redacted. Must be either `client` or `server`
</ParamField>

<ParamField type="string">
  ID of the client attempting to get the SDK settings
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

Returns SDK configuration settings including redaction rules and exclusion patterns.

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/buckets/bkt_xyz789uvw012rst345abc/sdk?redactAt=client&clientId=client_123" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/buckets/bkt_xyz789uvw012rst345abc/sdk?redactAt=client&clientId=client_123', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const settings = await response.json();
  console.log(settings);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "redactionRules": [
      {
        "field": "password",
        "action": "redact"
      }
    ],
    "exclusionRules": [
      {
        "path": "/health",
        "method": "GET"
      }
    ],
    "settings": {
      "interceptOutbound": true,
      "debug": false
    }
  }
  ```
</ResponseExample>


# Events
Source: https://docs.apitraffic.io/api-reference/events

Track deployments, incidents, and other markers to correlate with your API traffic

Events allow you to mark significant moments — deployments, incidents, configuration changes, scaling events — directly on your ApiTraffic dashboard charts. This makes it easy to correlate changes in error rates, latencies, and throughput with specific actions in your infrastructure.

## How Events Work

When you create an event, it appears as a vertical annotation on your Throughput and Response Time dashboard charts. This lets you visually answer questions like:

* "Did error rates spike after that deploy?"
* "Did response times improve after we scaled up?"
* "When exactly did that incident start?"

### Event Types

| Type            | Description                                 |
| --------------- | ------------------------------------------- |
| `deployment`    | Code releases, deploys, rollbacks           |
| `incident`      | Outages, degradations, alerts fired         |
| `config_change` | Feature flags, environment variable changes |
| `scale`         | Autoscaling events, manual scaling          |
| `custom`        | Anything else you want to track             |

### Scoping

Events can be scoped to specific **buckets** and/or **environments**, or applied globally:

* **`["*"]`** (default) — applies to all buckets or all environments
* **Specific SIDs** — e.g. `["bkt_abc123"]` to scope to a single bucket

Events scoped to a bucket will only appear on that bucket's dashboard. Events scoped to `["*"]` appear everywhere.

## Creating Events

There are three ways to create events:

### 1. Dashboard UI

Navigate to **Account → Events** and click **Create Event**. Fill in the type, name, description, and optionally scope to specific buckets and environments.

### 2. REST API

Send a `POST` request to create events programmatically — ideal for CI/CD pipelines.

### 3. MCP Server

If you have an MCP token configured, AI assistants can create events using the `create_event` tool.

***

## CI/CD Integration Examples

The most powerful use of events is automated creation from your CI/CD pipeline. Here are examples for common platforms:

<CodeGroup>
  ```yaml GitHub Actions theme={null}
  # Add to the end of your deploy job
  - name: Create ApiTraffic Deploy Event
    run: |
      curl -X POST "https://api.apitraffic.io/v1/accounts/${{ secrets.APITRAFFIC_ACCOUNT_SID }}/events" \
        -H "Authorization: Bearer ${{ secrets.APITRAFFIC_API_TOKEN }}" \
        -H "Content-Type: application/json" \
        -d '{
          "type": "deployment",
          "name": "${{ github.ref_name }} deploy",
          "description": "Commit: ${{ github.sha }}",
          "source": "github_actions",
          "metadata": {
            "commitSha": "${{ github.sha }}",
            "branch": "${{ github.ref_name }}",
            "actor": "${{ github.actor }}",
            "runId": "${{ github.run_id }}"
          }
        }'
  ```

  ```yaml GitLab CI theme={null}
  # Add to your deploy stage
  create_event:
    stage: deploy
    script:
      - |
        curl -X POST "https://api.apitraffic.io/v1/accounts/${APITRAFFIC_ACCOUNT_SID}/events" \
          -H "Authorization: Bearer ${APITRAFFIC_API_TOKEN}" \
          -H "Content-Type: application/json" \
          -d "{
            \"type\": \"deployment\",
            \"name\": \"${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA} deploy\",
            \"description\": \"Pipeline: ${CI_PIPELINE_ID}\",
            \"source\": \"gitlab_ci\",
            \"metadata\": {
              \"commitSha\": \"${CI_COMMIT_SHA}\",
              \"branch\": \"${CI_COMMIT_BRANCH}\",
              \"pipelineId\": \"${CI_PIPELINE_ID}\"
            }
          }"
  ```

  ```groovy Jenkins theme={null}
  // Add to the end of your Jenkinsfile
  post {
      success {
          sh """
              curl -X POST "https://api.apitraffic.io/v1/accounts/\${APITRAFFIC_ACCOUNT_SID}/events" \
                -H "Authorization: Bearer \${APITRAFFIC_API_TOKEN}" \
                -H "Content-Type: application/json" \
                -d '{
                  "type": "deployment",
                  "name": "${env.BUILD_TAG} deploy",
                  "source": "jenkins",
                  "metadata": {
                    "buildNumber": "${env.BUILD_NUMBER}",
                    "jobName": "${env.JOB_NAME}"
                  }
                }'
          """
      }
  }
  ```
</CodeGroup>

***

## List Events

<api-endpoint method="GET" />

Retrieve events for an account, with optional filtering by type, time range, and bucket.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

### Query Parameters

<ParamField type="string">
  Filter by event type: `deployment`, `incident`, `config_change`, `scale`, `custom`
</ParamField>

<ParamField type="string">
  ISO 8601 start time to filter events from
</ParamField>

<ParamField type="string">
  ISO 8601 end time to filter events until
</ParamField>

<ParamField type="string">
  Filter to events that apply to a specific bucket
</ParamField>

<ParamField type="string">
  Filter to events that apply to a specific environment
</ParamField>

<ParamField type="number">
  Maximum number of results (default: 25, max: 100)
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="hasMore" type="boolean">
  Indicates if there are more records to paginate through
</ResponseField>

<ResponseField name="records" type="array">
  <Expandable title="Event Objects">
    <ResponseField name="sid" type="string">
      Unique event identifier
    </ResponseField>

    <ResponseField name="accountSid" type="string">
      Account identifier this event belongs to
    </ResponseField>

    <ResponseField name="type" type="string">
      Event type: `deployment`, `incident`, `config_change`, `scale`, `custom`
    </ResponseField>

    <ResponseField name="name" type="string">
      Human-readable event name
    </ResponseField>

    <ResponseField name="description" type="string">
      Longer description of the event (nullable)
    </ResponseField>

    <ResponseField name="source" type="string">
      Source of the event, e.g. `github_actions`, `jenkins`, `manual` (nullable)
    </ResponseField>

    <ResponseField name="metadata" type="object">
      Freeform key/value metadata (nullable)
    </ResponseField>

    <ResponseField name="bucketSids" type="array">
      Bucket SIDs this event applies to. `["*"]` means all buckets.
    </ResponseField>

    <ResponseField name="environmentSids" type="array">
      Environment SIDs this event applies to. `["*"]` means all environments.
    </ResponseField>

    <ResponseField name="startedAt" type="string">
      ISO 8601 timestamp when the event started
    </ResponseField>

    <ResponseField name="endedAt" type="string">
      ISO 8601 timestamp when the event ended (nullable for point-in-time events)
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp of event creation
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events?type=deployment&limit=10" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events?type=deployment&limit=10', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const events = await response.json();
  console.log(events);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events',
      headers={'Authorization': 'Bearer your-jwt-token'},
      params={'type': 'deployment', 'limit': 10}
  )

  events = response.json()
  print(events)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "hasMore": false,
    "records": [
      {
        "sid": "evt_abc123def456ghi789jkl012",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "type": "deployment",
        "name": "v2.3.1 production release",
        "description": "Commit: a1b2c3d4",
        "source": "github_actions",
        "metadata": {
          "commitSha": "a1b2c3d4e5f6",
          "branch": "main",
          "actor": "jsmith"
        },
        "bucketSids": ["*"],
        "environmentSids": ["*"],
        "startedAt": "2024-01-15T14:30:00.000Z",
        "endedAt": null,
        "createdAt": "2024-01-15T14:30:05.000Z"
      }
    ]
  }
  ```
</ResponseExample>

***

## Get Event

<api-endpoint method="GET" />

Retrieve details of a specific event.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Event identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

Returns a single event object with the same structure as described in the List Events response.

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events/evt_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events/evt_abc123def456ghi789jkl012', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const event = await response.json();
  console.log(event);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "evt_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "type": "deployment",
    "name": "v2.3.1 production release",
    "description": "Commit: a1b2c3d4",
    "source": "github_actions",
    "metadata": {
      "commitSha": "a1b2c3d4e5f6",
      "branch": "main"
    },
    "bucketSids": ["*"],
    "environmentSids": ["*"],
    "startedAt": "2024-01-15T14:30:00.000Z",
    "endedAt": null,
    "createdAt": "2024-01-15T14:30:05.000Z"
  }
  ```
</ResponseExample>

***

## Create Event

<api-endpoint method="POST" />

Create a new event marker.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Event type: `deployment`, `incident`, `config_change`, `scale`, `custom`
</ParamField>

<ParamField type="string">
  Human-readable event name (e.g. "v2.3.1 production release")
</ParamField>

<ParamField type="string">
  Longer description of the event
</ParamField>

<ParamField type="string">
  Source of the event (e.g. `github_actions`, `gitlab_ci`, `jenkins`, `manual`)
</ParamField>

<ParamField type="object">
  Freeform key/value metadata. Use this to store commit SHAs, branch names, image tags, or any other context.
</ParamField>

<ParamField type="array">
  Bucket SIDs this event applies to. Defaults to `["*"]` (all buckets).
</ParamField>

<ParamField type="array">
  Environment SIDs this event applies to. Defaults to `["*"]` (all environments).
</ParamField>

<ParamField type="string">
  ISO 8601 timestamp when the event started. Defaults to the current time.
</ParamField>

<ParamField type="string">
  ISO 8601 timestamp when the event ended. Leave null for point-in-time events (e.g. a deploy).
</ParamField>

### Response

Returns the created event object.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "deployment",
      "name": "v2.3.1 production release",
      "description": "Deployed from main branch",
      "source": "github_actions",
      "metadata": {
        "commitSha": "a1b2c3d4e5f6",
        "branch": "main",
        "imageTag": "v2.3.1"
      }
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      type: 'deployment',
      name: 'v2.3.1 production release',
      description: 'Deployed from main branch',
      source: 'github_actions',
      metadata: {
        commitSha: 'a1b2c3d4e5f6',
        branch: 'main',
        imageTag: 'v2.3.1'
      }
    })
  });

  const event = await response.json();
  console.log(event);
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events',
      headers={
          'Authorization': 'Bearer your-jwt-token',
          'Content-Type': 'application/json'
      },
      json={
          'type': 'deployment',
          'name': 'v2.3.1 production release',
          'description': 'Deployed from main branch',
          'source': 'github_actions',
          'metadata': {
              'commitSha': 'a1b2c3d4e5f6',
              'branch': 'main',
              'imageTag': 'v2.3.1'
          }
      }
  )

  event = response.json()
  print(event)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "evt_new789uvw012rst345def",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "type": "deployment",
    "name": "v2.3.1 production release",
    "description": "Deployed from main branch",
    "source": "github_actions",
    "metadata": {
      "commitSha": "a1b2c3d4e5f6",
      "branch": "main",
      "imageTag": "v2.3.1"
    },
    "bucketSids": ["*"],
    "environmentSids": ["*"],
    "startedAt": "2024-01-15T14:30:00.000Z",
    "endedAt": null,
    "createdAt": "2024-01-15T14:30:05.000Z"
  }
  ```
</ResponseExample>

***

## Update Event

<api-endpoint method="PUT" />

Update an existing event. Useful for setting the `endedAt` time on an incident or updating metadata.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Event identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

All fields from the Create Event request body are accepted. Only provided fields will be updated.

### Response

Returns the updated event object.

<RequestExample>
  ```bash cURL theme={null}
  curl -X PUT "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events/evt_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "endedAt": "2024-01-15T15:00:00.000Z",
      "description": "Incident resolved - root cause was database connection pool exhaustion"
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events/evt_abc123def456ghi789jkl012', {
    method: 'PUT',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      endedAt: '2024-01-15T15:00:00.000Z',
      description: 'Incident resolved - root cause was database connection pool exhaustion'
    })
  });

  const event = await response.json();
  console.log(event);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "evt_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "type": "incident",
    "name": "Database connection spike",
    "description": "Incident resolved - root cause was database connection pool exhaustion",
    "source": "manual",
    "metadata": null,
    "bucketSids": ["*"],
    "environmentSids": ["*"],
    "startedAt": "2024-01-15T14:00:00.000Z",
    "endedAt": "2024-01-15T15:00:00.000Z",
    "createdAt": "2024-01-15T14:05:00.000Z"
  }
  ```
</ResponseExample>

***

## Delete Event

<api-endpoint method="DELETE" />

Delete an event marker.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Event identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="sid" type="string">
  ID of the deleted event
</ResponseField>

<ResponseField name="deleted" type="boolean">
  Flag indicating the event was successfully deleted
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X DELETE "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events/evt_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/events/evt_abc123def456ghi789jkl012', {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const result = await response.json();
  console.log(result);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "evt_abc123def456ghi789jkl012",
    "deleted": true
  }
  ```
</ResponseExample>

***

## MCP Server Access

Events are also accessible through the ApiTraffic MCP server, allowing AI assistants to create and list events:

| Tool           | Description                                                       |
| -------------- | ----------------------------------------------------------------- |
| `list_events`  | List event markers with filtering by type, time range, and bucket |
| `create_event` | Create a new event marker                                         |

To use MCP tools, you need an MCP token configured in your account. See [MCP Tokens](/api-reference/mcp-tokens) for setup instructions.

## Best Practices

<Tip>
  **Automate event creation** — The most valuable events are created automatically by your CI/CD pipeline. Add a deploy event step to every release workflow so you never miss a correlation.
</Tip>

* **Use descriptive names** — Include version numbers, branch names, or ticket IDs in event names so they're meaningful at a glance on the chart.
* **Add metadata** — Store commit SHAs, Docker image tags, PR numbers, and other context in the `metadata` field. This makes it easy to trace back from a traffic anomaly to the exact change.
* **Scope when possible** — If a deploy only affects one service/bucket, scope the event to that bucket. This keeps dashboards clean and focused.
* **Close incidents** — When an incident is resolved, update the event with an `endedAt` timestamp and a description of the resolution.
* **Use consistent sources** — Standardize on source names like `github_actions`, `gitlab_ci`, `jenkins`, `manual` across your team.


# Exclusions
Source: https://docs.apitraffic.io/api-reference/exclusions

Manage request exclusion rules to filter out unwanted traffic

## List Exclusions

<api-endpoint method="GET" />

Retrieve all exclusion rules configured for an account.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="hasMore" type="boolean">
  Indicates if there are more records to paginate through
</ResponseField>

<ResponseField name="records" type="array">
  <Expandable title="Exclusion Objects">
    <ResponseField name="sid" type="string">
      Unique exclusion rule identifier
    </ResponseField>

    <ResponseField name="accountSid" type="string">
      Account identifier this exclusion belongs to
    </ResponseField>

    <ResponseField name="name" type="string">
      Name of the exclusion rule
    </ResponseField>

    <ResponseField name="description" type="string">
      Description of what this rule excludes
    </ResponseField>

    <ResponseField name="pathPattern" type="string">
      URL path pattern to match (supports wildcards)
    </ResponseField>

    <ResponseField name="method" type="string">
      HTTP method to match (GET, POST, PUT, DELETE, etc.) or \* for all
    </ResponseField>

    <ResponseField name="statusCode" type="number">
      HTTP status code to match (nullable, null means all status codes)
    </ResponseField>

    <ResponseField name="isActive" type="boolean">
      Whether this exclusion rule is currently active
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp of rule creation
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const exclusions = await response.json();
  console.log(exclusions);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions',
      headers={'Authorization': 'Bearer your-jwt-token'}
  )

  exclusions = response.json()
  print(exclusions)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "hasMore": false,
    "records": [
      {
        "sid": "exc_abc123def456ghi789jkl012",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "name": "Health Check Exclusion",
        "description": "Excludes health check endpoints from monitoring",
        "pathPattern": "/health*",
        "method": "GET",
        "statusCode": null,
        "isActive": true,
        "createdAt": "2023-12-01T10:30:00.000Z"
      },
      {
        "sid": "exc_xyz789uvw012rst345abc",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "name": "Static Assets",
        "description": "Excludes static asset requests",
        "pathPattern": "/static/*",
        "method": "*",
        "statusCode": null,
        "isActive": true,
        "createdAt": "2023-12-01T11:15:00.000Z"
      }
    ]
  }
  ```
</ResponseExample>

***

## Get Exclusion

<api-endpoint method="GET" />

Retrieve details of a specific exclusion rule.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Exclusion rule identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

Returns a single exclusion object with the same structure as described in the List Exclusions response.

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions/exc_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions/exc_abc123def456ghi789jkl012', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const exclusion = await response.json();
  console.log(exclusion);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "exc_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Health Check Exclusion",
    "description": "Excludes health check endpoints from monitoring",
    "pathPattern": "/health*",
    "method": "GET",
    "statusCode": null,
    "isActive": true,
    "createdAt": "2023-12-01T10:30:00.000Z"
  }
  ```
</ResponseExample>

***

## Create Exclusion

<api-endpoint method="POST" />

Create a new exclusion rule to filter out unwanted requests from monitoring.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Name of the exclusion rule
</ParamField>

<ParamField type="string">
  Description of what this rule excludes
</ParamField>

<ParamField type="string">
  URL path pattern to match. Supports wildcards (\*) and exact matches
</ParamField>

<ParamField type="string">
  HTTP method to match (GET, POST, PUT, DELETE, etc.) or \* for all methods
</ParamField>

<ParamField type="number">
  HTTP status code to match (optional, null means all status codes)
</ParamField>

<ParamField type="boolean">
  Whether this exclusion rule should be active (default: true)
</ParamField>

### Response

Returns the created exclusion object.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Metrics Exclusion",
      "description": "Excludes internal metrics endpoints",
      "pathPattern": "/metrics/*",
      "method": "*",
      "isActive": true
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Metrics Exclusion',
      description: 'Excludes internal metrics endpoints',
      pathPattern: '/metrics/*',
      method: '*',
      isActive: true
    })
  });

  const exclusion = await response.json();
  console.log(exclusion);
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions',
      headers={
          'Authorization': 'Bearer your-jwt-token',
          'Content-Type': 'application/json'
      },
      json={
          'name': 'Metrics Exclusion',
          'description': 'Excludes internal metrics endpoints',
          'pathPattern': '/metrics/*',
          'method': '*',
          'isActive': True
      }
  )

  exclusion = response.json()
  print(exclusion)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "exc_new789uvw012rst345def",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Metrics Exclusion",
    "description": "Excludes internal metrics endpoints",
    "pathPattern": "/metrics/*",
    "method": "*",
    "statusCode": null,
    "isActive": true,
    "createdAt": "2023-12-01T15:45:00.000Z"
  }
  ```
</ResponseExample>

***

## Update Exclusion

<api-endpoint method="PUT" />

Update an existing exclusion rule.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Exclusion rule identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Name of the exclusion rule
</ParamField>

<ParamField type="string">
  Description of what this rule excludes
</ParamField>

<ParamField type="string">
  URL path pattern to match
</ParamField>

<ParamField type="string">
  HTTP method to match or \* for all methods
</ParamField>

<ParamField type="number">
  HTTP status code to match (optional)
</ParamField>

<ParamField type="boolean">
  Whether this exclusion rule should be active
</ParamField>

### Response

Returns the updated exclusion object.

<RequestExample>
  ```bash cURL theme={null}
  curl -X PUT "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions/exc_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Updated Health Check Exclusion",
      "description": "Excludes all health check and status endpoints",
      "pathPattern": "/health*",
      "method": "*",
      "statusCode": 200,
      "isActive": true
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions/exc_abc123def456ghi789jkl012', {
    method: 'PUT',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Updated Health Check Exclusion',
      description: 'Excludes all health check and status endpoints',
      pathPattern: '/health*',
      method: '*',
      statusCode: 200,
      isActive: true
    })
  });

  const exclusion = await response.json();
  console.log(exclusion);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "exc_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Updated Health Check Exclusion",
    "description": "Excludes all health check and status endpoints",
    "pathPattern": "/health*",
    "method": "*",
    "statusCode": 200,
    "isActive": true,
    "createdAt": "2023-12-01T10:30:00.000Z"
  }
  ```
</ResponseExample>

***

## Delete Exclusion

<api-endpoint method="DELETE" />

Delete an exclusion rule.

<Warning>
  Deleting an exclusion rule will cause previously excluded requests to be monitored again if they match other patterns.
</Warning>

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Exclusion rule identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="sid" type="string">
  ID of the deleted exclusion rule
</ResponseField>

<ResponseField name="deleted" type="boolean">
  Flag indicating the exclusion rule was successfully deleted
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X DELETE "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions/exc_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/exclusions/exc_abc123def456ghi789jkl012', {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const result = await response.json();
  console.log(result);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "exc_abc123def456ghi789jkl012",
    "deleted": true
  }
  ```
</ResponseExample>

***

## Path Pattern Examples

Exclusion rules support flexible path matching patterns:

<CodeGroup>
  ```text Exact Match theme={null}
  /health
  // Matches only: /health
  ```

  ```text Wildcard Suffix theme={null}
  /health*
  // Matches: /health, /health-check, /healthz
  ```

  ```text Wildcard Prefix theme={null}
  */admin
  // Matches: /api/admin, /v1/admin, /internal/admin
  ```

  ```text Wildcard Middle theme={null}
  /api/*/status
  // Matches: /api/users/status, /api/orders/status
  ```

  ```text Multiple Wildcards theme={null}
  /api/*/v*/health*
  // Matches: /api/users/v1/health, /api/orders/v2/healthcheck
  ```
</CodeGroup>

## Common Exclusion Patterns

### Health Checks

```json theme={null}
{
  "name": "Health Checks",
  "pathPattern": "/health*",
  "method": "GET"
}
```

### Static Assets

```json theme={null}
{
  "name": "Static Assets", 
  "pathPattern": "/static/*",
  "method": "*"
}
```

### Internal APIs

```json theme={null}
{
  "name": "Internal APIs",
  "pathPattern": "/internal/*",
  "method": "*"
}
```

### Successful Options Requests

```json theme={null}
{
  "name": "CORS Preflight",
  "pathPattern": "*",
  "method": "OPTIONS",
  "statusCode": 200
}
```

### Admin Endpoints

```json theme={null}
{
  "name": "Admin Panel",
  "pathPattern": "/admin/*",
  "method": "*"
}
```


# Introduction
Source: https://docs.apitraffic.io/api-reference/introduction

REST API documentation for ApiTraffic platform

## Welcome to ApiTraffic API

The ApiTraffic API provides programmatic access to your API monitoring data, configuration, and analytics. Our REST API is designed to be simple, predictable, and easy to integrate with your existing workflows.

## Base URL

```
https://api.apitraffic.io/v1
```

## Authentication

All API requests require authentication using your API token. Include your token in the `Authorization` header:

```bash theme={null}
curl -H "Authorization: Bearer your-api-token" \
  https://api.apitraffic.io/v1/buckets
```

## Rate Limiting

API requests are rate limited to ensure fair usage:

* **Standard Plan**: 1,000 requests per hour
* **Pro Plan**: 10,000 requests per hour
* **Enterprise Plan**: Custom limits

Rate limit headers are included in all responses:

```
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1640995200
```

## Response Format

All API responses are returned in JSON format:

```json theme={null}
{
  "success": true,
  "data": {
    // Response data
  },
  "meta": {
    "page": 1,
    "limit": 50,
    "total": 100
  }
}
```

## Error Handling

Errors are returned with appropriate HTTP status codes and descriptive messages:

```json theme={null}
{
  "success": false,
  "error": {
    "code": "INVALID_TOKEN",
    "message": "The provided API token is invalid",
    "details": {}
  }
}
```

### Common Error Codes

| Code                  | Description                      |
| --------------------- | -------------------------------- |
| `INVALID_TOKEN`       | API token is missing or invalid  |
| `RATE_LIMIT_EXCEEDED` | Too many requests                |
| `RESOURCE_NOT_FOUND`  | Requested resource doesn't exist |
| `VALIDATION_ERROR`    | Request validation failed        |
| `INTERNAL_ERROR`      | Server error occurred            |

## Pagination

List endpoints support pagination using `page` and `limit` parameters:

```bash theme={null}
curl "https://api.apitraffic.io/v1/requests?page=2&limit=25" \
  -H "Authorization: Bearer your-api-token"
```

## Filtering and Sorting

Many endpoints support filtering and sorting:

```bash theme={null}
# Filter by date range
curl "https://api.apitraffic.io/v1/requests?start_date=2023-01-01&end_date=2023-01-31" \
  -H "Authorization: Bearer your-api-token"

# Sort by timestamp
curl "https://api.apitraffic.io/v1/requests?sort=timestamp&order=desc" \
  -H "Authorization: Bearer your-api-token"
```

## SDKs and Libraries

Official SDKs are available for popular languages:

* **Node.js**: `@apitraffic/node-sdk`
* **Python**: `apitraffic-python`
* **PHP**: `apitraffic/php-sdk`
* **Go**: `github.com/apitraffic/go-sdk`

## Getting Started

1. [Get your API token](https://app.apitraffic.io/settings/api)
2. Make your first API call
3. Explore the available endpoints
4. Integrate with your applications


# MCP Tokens
Source: https://docs.apitraffic.io/api-reference/mcp-tokens

Manage MCP tokens for AI assistant access to your ApiTraffic data

## List MCP Tokens

<api-endpoint method="GET" />

Retrieve all MCP tokens associated with an account.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="hasMore" type="boolean">
  Indicates if there are more records to paginate through
</ResponseField>

<ResponseField name="records" type="array">
  <Expandable title="MCP Token Objects">
    <ResponseField name="sid" type="string">
      Unique MCP token identifier (format: `mcp_` prefix)
    </ResponseField>

    <ResponseField name="accountSid" type="string">
      Account identifier this token belongs to
    </ResponseField>

    <ResponseField name="environmentSid" type="string">
      Environment this token is scoped to
    </ResponseField>

    <ResponseField name="bucketSids" type="array">
      Array of bucket SIDs this token can access. Empty array means all buckets in the environment.
    </ResponseField>

    <ResponseField name="name" type="string">
      Name of the MCP token
    </ResponseField>

    <ResponseField name="token" type="string">
      Masked token value (full value only shown on creation)
    </ResponseField>

    <ResponseField name="isRevoked" type="boolean">
      Whether this token has been revoked
    </ResponseField>

    <ResponseField name="lastUsedAt" type="string">
      ISO 8601 timestamp of last token usage (nullable)
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp of token creation
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/mcpTokens" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/mcpTokens', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const tokens = await response.json();
  console.log(tokens);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "hasMore": false,
    "records": [
      {
        "sid": "mcp_abc123def456ghi789jkl012",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "environmentSid": "prod01",
        "bucketSids": [],
        "name": "Claude Desktop - Production",
        "token": "mcp_2abc1*******ef789",
        "isRevoked": false,
        "lastUsedAt": "2025-03-15T14:30:00.000Z",
        "createdAt": "2025-03-15T10:30:00.000Z",
        "updatedAt": "2025-03-15T10:30:00.000Z",
        "revokedAt": null
      }
    ]
  }
  ```
</ResponseExample>

***

## Create MCP Token

<api-endpoint method="POST" />

Create a new MCP token for AI assistant access. MCP tokens are read-only and scoped to a specific environment and set of buckets.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  A descriptive name for the MCP token (e.g. "Claude Desktop - Production")
</ParamField>

<ParamField type="string">
  The environment SID this token should be scoped to
</ParamField>

<ParamField type="array">
  Array of bucket SIDs to restrict access to. Leave empty or omit to grant access to all buckets in the environment.
</ParamField>

### Response

Returns the created MCP token with the **full token value** (only shown once).

<Warning>
  The token value is only returned once during creation. Store it securely as it cannot be retrieved again.
</Warning>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/mcpTokens" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Claude Desktop - Production",
      "environmentSid": "prod01",
      "bucketSids": []
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/mcpTokens', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Claude Desktop - Production',
      environmentSid: 'prod01',
      bucketSids: []
    })
  });

  const token = await response.json();
  console.log(token);
  // Store token.token securely!
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "mcp_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "environmentSid": "prod01",
    "bucketSids": [],
    "name": "Claude Desktop - Production",
    "token": "mcp_2abc1d3e4f5g6h7i8j9k0l1m2n3o4p5q6r7s8t9u0v1w2x3y4z",
    "isRevoked": false,
    "lastUsedAt": null,
    "createdAt": "2025-03-15T10:30:00.000Z",
    "updatedAt": "2025-03-15T10:30:00.000Z",
    "revokedAt": null
  }
  ```
</ResponseExample>

***

## Update MCP Token

<api-endpoint method="PUT" />

Update an existing MCP token's name or bucket scope.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  MCP token identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Updated name for the token
</ParamField>

<ParamField type="array">
  Updated array of bucket SIDs (empty = all buckets in environment)
</ParamField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X PUT "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/mcpTokens/mcp_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Claude Desktop - Staging",
      "bucketSids": ["abc1234", "def5678"]
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "mcp_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "environmentSid": "prod01",
    "bucketSids": ["abc1234", "def5678"],
    "name": "Claude Desktop - Staging",
    "token": "mcp_2abc1*******ef789",
    "isRevoked": false,
    "lastUsedAt": "2025-03-15T14:30:00.000Z",
    "createdAt": "2025-03-15T10:30:00.000Z",
    "updatedAt": "2025-03-15T15:00:00.000Z",
    "revokedAt": null
  }
  ```
</ResponseExample>

***

## Revoke MCP Token

<api-endpoint method="DELETE" />

Revoke an MCP token, immediately terminating access for any AI assistants using it.

<Warning>
  This action is immediate. Any AI assistants using this token will lose access instantly.
</Warning>

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  MCP token identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X DELETE "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/mcpTokens/mcp_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/mcpTokens/mcp_abc123def456ghi789jkl012', {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const result = await response.json();
  console.log(result);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "mcp_abc123def456ghi789jkl012",
    "deleted": true
  }
  ```
</ResponseExample>


# Metrics
Source: https://docs.apitraffic.io/api-reference/metrics

Retrieve analytics and performance metrics for your API traffic

## Get Summary Metrics

<api-endpoint method="GET" />

Retrieve summary metrics for an account, with optional filtering capabilities.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

### Query Parameters

<ParamField type="string">
  Filter metrics by specific bucket
</ParamField>

<ParamField type="string">
  Start date for metrics (ISO 8601 format)
</ParamField>

<ParamField type="string">
  End date for metrics (ISO 8601 format)
</ParamField>

<ParamField type="string">
  Filter by environment identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="totalRequests" type="number">
  Total number of requests in the time period
</ResponseField>

<ResponseField name="totalErrors" type="number">
  Total number of error responses (4xx/5xx status codes)
</ResponseField>

<ResponseField name="averageResponseTime" type="number">
  Average response time in milliseconds
</ResponseField>

<ResponseField name="totalDataTransferred" type="number">
  Total bytes transferred (request + response)
</ResponseField>

<ResponseField name="requestsByMethod" type="object">
  Breakdown of requests by HTTP method
</ResponseField>

<ResponseField name="requestsByStatus" type="object">
  Breakdown of requests by HTTP status code ranges
</ResponseField>

<ResponseField name="topEndpoints" type="array">
  Most frequently accessed endpoints
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/summary?startDate=2023-12-01T00:00:00Z&endDate=2023-12-02T00:00:00Z" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/summary?startDate=2023-12-01T00:00:00Z&endDate=2023-12-02T00:00:00Z', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const metrics = await response.json();
  console.log(metrics);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/summary',
      params={
          'startDate': '2023-12-01T00:00:00Z',
          'endDate': '2023-12-02T00:00:00Z'
      },
      headers={'Authorization': 'Bearer your-jwt-token'}
  )

  metrics = response.json()
  print(metrics)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "totalRequests": 15420,
    "totalErrors": 234,
    "averageResponseTime": 145.6,
    "totalDataTransferred": 2048576,
    "requestsByMethod": {
      "GET": 12340,
      "POST": 2100,
      "PUT": 680,
      "DELETE": 300
    },
    "requestsByStatus": {
      "2xx": 14186,
      "3xx": 1000,
      "4xx": 200,
      "5xx": 34
    },
    "topEndpoints": [
      {
        "path": "/api/users",
        "count": 3420,
        "averageResponseTime": 120.5
      },
      {
        "path": "/api/orders",
        "count": 2100,
        "averageResponseTime": 180.2
      }
    ]
  }
  ```
</ResponseExample>

***

## Get Throughput Metrics

<api-endpoint method="GET" />

Retrieve request throughput metrics over time.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Query Parameters

<ParamField type="string">
  Filter metrics by specific bucket
</ParamField>

<ParamField type="string">
  Start date for metrics (ISO 8601 format)
</ParamField>

<ParamField type="string">
  End date for metrics (ISO 8601 format)
</ParamField>

<ParamField type="string">
  Time interval for grouping: `hour`, `day`, `week`, `month`
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="interval" type="string">
  Time interval used for grouping
</ResponseField>

<ResponseField name="data" type="array">
  <Expandable title="Throughput Data Points">
    <ResponseField name="timestamp" type="string">
      ISO 8601 timestamp for the data point
    </ResponseField>

    <ResponseField name="requestCount" type="number">
      Number of requests in this time interval
    </ResponseField>

    <ResponseField name="errorCount" type="number">
      Number of errors in this time interval
    </ResponseField>

    <ResponseField name="averageResponseTime" type="number">
      Average response time for this interval
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/throughput?interval=hour&startDate=2023-12-01T00:00:00Z&endDate=2023-12-02T00:00:00Z" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/throughput?interval=hour&startDate=2023-12-01T00:00:00Z&endDate=2023-12-02T00:00:00Z', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const throughput = await response.json();
  console.log(throughput);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "interval": "hour",
    "data": [
      {
        "timestamp": "2023-12-01T00:00:00Z",
        "requestCount": 450,
        "errorCount": 12,
        "averageResponseTime": 142.3
      },
      {
        "timestamp": "2023-12-01T01:00:00Z",
        "requestCount": 523,
        "errorCount": 8,
        "averageResponseTime": 138.7
      }
    ]
  }
  ```
</ResponseExample>

***

## Get Performance Metrics

<api-endpoint method="GET" />

Retrieve detailed performance metrics including response times, error rates, and endpoint analytics.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Query Parameters

<ParamField type="string">
  Filter metrics by specific bucket
</ParamField>

<ParamField type="string">
  Start date for metrics (ISO 8601 format)
</ParamField>

<ParamField type="string">
  End date for metrics (ISO 8601 format)
</ParamField>

<ParamField type="string">
  Group metrics by: `endpoint`, `method`, `status`, `environment`
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="groupBy" type="string">
  The grouping method used
</ResponseField>

<ResponseField name="metrics" type="array">
  <Expandable title="Performance Metrics">
    <ResponseField name="group" type="string">
      The group identifier (endpoint, method, etc.)
    </ResponseField>

    <ResponseField name="requestCount" type="number">
      Total requests for this group
    </ResponseField>

    <ResponseField name="errorRate" type="number">
      Error rate as a percentage (0-100)
    </ResponseField>

    <ResponseField name="averageResponseTime" type="number">
      Average response time in milliseconds
    </ResponseField>

    <ResponseField name="p50ResponseTime" type="number">
      50th percentile response time
    </ResponseField>

    <ResponseField name="p95ResponseTime" type="number">
      95th percentile response time
    </ResponseField>

    <ResponseField name="p99ResponseTime" type="number">
      99th percentile response time
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/performance?groupBy=endpoint&startDate=2023-12-01T00:00:00Z&endDate=2023-12-02T00:00:00Z" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/performance?groupBy=endpoint&startDate=2023-12-01T00:00:00Z&endDate=2023-12-02T00:00:00Z', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const performance = await response.json();
  console.log(performance);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "groupBy": "endpoint",
    "metrics": [
      {
        "group": "/api/users",
        "requestCount": 3420,
        "errorRate": 1.2,
        "averageResponseTime": 120.5,
        "p50ResponseTime": 95.0,
        "p95ResponseTime": 280.0,
        "p99ResponseTime": 450.0
      },
      {
        "group": "/api/orders",
        "requestCount": 2100,
        "errorRate": 2.8,
        "averageResponseTime": 180.2,
        "p50ResponseTime": 145.0,
        "p95ResponseTime": 420.0,
        "p99ResponseTime": 650.0
      }
    ]
  }
  ```
</ResponseExample>

***

## Get Error Metrics

<api-endpoint method="GET" />

Retrieve detailed error analysis and patterns.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Query Parameters

<ParamField type="string">
  Filter metrics by specific bucket
</ParamField>

<ParamField type="string">
  Start date for metrics (ISO 8601 format)
</ParamField>

<ParamField type="string">
  End date for metrics (ISO 8601 format)
</ParamField>

<ParamField type="number">
  Filter by specific HTTP status code
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="totalErrors" type="number">
  Total number of errors in the time period
</ResponseField>

<ResponseField name="errorRate" type="number">
  Overall error rate as a percentage
</ResponseField>

<ResponseField name="errorsByStatus" type="object">
  Breakdown of errors by HTTP status code
</ResponseField>

<ResponseField name="errorsByEndpoint" type="array">
  <Expandable title="Endpoint Error Analysis">
    <ResponseField name="endpoint" type="string">
      API endpoint path
    </ResponseField>

    <ResponseField name="errorCount" type="number">
      Number of errors for this endpoint
    </ResponseField>

    <ResponseField name="errorRate" type="number">
      Error rate percentage for this endpoint
    </ResponseField>

    <ResponseField name="mostCommonErrors" type="array">
      Most frequent error status codes
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/errors?startDate=2023-12-01T00:00:00Z&endDate=2023-12-02T00:00:00Z" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/metrics/errors?startDate=2023-12-01T00:00:00Z&endDate=2023-12-02T00:00:00Z', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const errors = await response.json();
  console.log(errors);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "totalErrors": 234,
    "errorRate": 1.52,
    "errorsByStatus": {
      "400": 120,
      "401": 45,
      "404": 35,
      "500": 25,
      "503": 9
    },
    "errorsByEndpoint": [
      {
        "endpoint": "/api/auth/login",
        "errorCount": 45,
        "errorRate": 3.2,
        "mostCommonErrors": [401, 400]
      },
      {
        "endpoint": "/api/users/profile",
        "errorCount": 35,
        "errorRate": 2.1,
        "mostCommonErrors": [404, 403]
      }
    ]
  }
  ```
</ResponseExample>


# Redactions
Source: https://docs.apitraffic.io/api-reference/redactions

Manage data redaction rules to protect sensitive information

## List Redactions

<api-endpoint method="GET" />

Retrieve all redaction rules configured for an account.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="hasMore" type="boolean">
  Indicates if there are more records to paginate through
</ResponseField>

<ResponseField name="records" type="array">
  <Expandable title="Redaction Objects">
    <ResponseField name="sid" type="string">
      Unique redaction rule identifier
    </ResponseField>

    <ResponseField name="accountSid" type="string">
      Account identifier this redaction belongs to
    </ResponseField>

    <ResponseField name="name" type="string">
      Name of the redaction rule
    </ResponseField>

    <ResponseField name="description" type="string">
      Description of what this rule redacts
    </ResponseField>

    <ResponseField name="fieldPath" type="string">
      JSON path to the field to be redacted
    </ResponseField>

    <ResponseField name="redactionType" type="string">
      Type of redaction: `mask`, `remove`, `hash`, `replace`
    </ResponseField>

    <ResponseField name="replacementValue" type="string">
      Value to use when redactionType is `replace` (nullable)
    </ResponseField>

    <ResponseField name="isActive" type="boolean">
      Whether this redaction rule is currently active
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp of rule creation
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const redactions = await response.json();
  console.log(redactions);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions',
      headers={'Authorization': 'Bearer your-jwt-token'}
  )

  redactions = response.json()
  print(redactions)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "hasMore": false,
    "records": [
      {
        "sid": "red_abc123def456ghi789jkl012",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "name": "Password Redaction",
        "description": "Redacts password fields from request bodies",
        "fieldPath": "$.password",
        "redactionType": "mask",
        "replacementValue": null,
        "isActive": true,
        "createdAt": "2023-12-01T10:30:00.000Z"
      },
      {
        "sid": "red_xyz789uvw012rst345abc",
        "accountSid": "acc_abc123def456ghi789jkl012",
        "name": "Credit Card Masking",
        "description": "Masks credit card numbers",
        "fieldPath": "$.payment.cardNumber",
        "redactionType": "mask",
        "replacementValue": null,
        "isActive": true,
        "createdAt": "2023-12-01T11:15:00.000Z"
      }
    ]
  }
  ```
</ResponseExample>

***

## Get Redaction

<api-endpoint method="GET" />

Retrieve details of a specific redaction rule.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Redaction rule identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

Returns a single redaction object with the same structure as described in the List Redactions response.

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions/red_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions/red_abc123def456ghi789jkl012', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const redaction = await response.json();
  console.log(redaction);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "red_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Password Redaction",
    "description": "Redacts password fields from request bodies",
    "fieldPath": "$.password",
    "redactionType": "mask",
    "replacementValue": null,
    "isActive": true,
    "createdAt": "2023-12-01T10:30:00.000Z"
  }
  ```
</ResponseExample>

***

## Create Redaction

<api-endpoint method="POST" />

Create a new redaction rule to protect sensitive data.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Name of the redaction rule
</ParamField>

<ParamField type="string">
  Description of what this rule redacts
</ParamField>

<ParamField type="string">
  JSON path to the field to be redacted (e.g., `$.password`, `$.user.email`)
</ParamField>

<ParamField type="string">
  Type of redaction: `mask`, `remove`, `hash`, or `replace`
</ParamField>

<ParamField type="string">
  Value to use when redactionType is `replace`
</ParamField>

<ParamField type="boolean">
  Whether this redaction rule should be active (default: true)
</ParamField>

### Response

Returns the created redaction object.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Email Redaction",
      "description": "Masks email addresses in user data",
      "fieldPath": "$.user.email",
      "redactionType": "mask",
      "isActive": true
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Email Redaction',
      description: 'Masks email addresses in user data',
      fieldPath: '$.user.email',
      redactionType: 'mask',
      isActive: true
    })
  });

  const redaction = await response.json();
  console.log(redaction);
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions',
      headers={
          'Authorization': 'Bearer your-jwt-token',
          'Content-Type': 'application/json'
      },
      json={
          'name': 'Email Redaction',
          'description': 'Masks email addresses in user data',
          'fieldPath': '$.user.email',
          'redactionType': 'mask',
          'isActive': True
      }
  )

  redaction = response.json()
  print(redaction)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "red_new789uvw012rst345def",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Email Redaction",
    "description": "Masks email addresses in user data",
    "fieldPath": "$.user.email",
    "redactionType": "mask",
    "replacementValue": null,
    "isActive": true,
    "createdAt": "2023-12-01T15:45:00.000Z"
  }
  ```
</ResponseExample>

***

## Update Redaction

<api-endpoint method="PUT" />

Update an existing redaction rule.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Redaction rule identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Name of the redaction rule
</ParamField>

<ParamField type="string">
  Description of what this rule redacts
</ParamField>

<ParamField type="string">
  JSON path to the field to be redacted
</ParamField>

<ParamField type="string">
  Type of redaction: `mask`, `remove`, `hash`, or `replace`
</ParamField>

<ParamField type="string">
  Value to use when redactionType is `replace`
</ParamField>

<ParamField type="boolean">
  Whether this redaction rule should be active
</ParamField>

### Response

Returns the updated redaction object.

<RequestExample>
  ```bash cURL theme={null}
  curl -X PUT "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions/red_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Updated Password Redaction",
      "description": "Redacts all password fields from requests and responses",
      "fieldPath": "$.password",
      "redactionType": "remove",
      "isActive": true
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions/red_abc123def456ghi789jkl012', {
    method: 'PUT',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Updated Password Redaction',
      description: 'Redacts all password fields from requests and responses',
      fieldPath: '$.password',
      redactionType: 'remove',
      isActive: true
    })
  });

  const redaction = await response.json();
  console.log(redaction);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "red_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "name": "Updated Password Redaction",
    "description": "Redacts all password fields from requests and responses",
    "fieldPath": "$.password",
    "redactionType": "remove",
    "replacementValue": null,
    "isActive": true,
    "createdAt": "2023-12-01T10:30:00.000Z"
  }
  ```
</ResponseExample>

***

## Delete Redaction

<api-endpoint method="DELETE" />

Delete a redaction rule.

<Warning>
  Deleting a redaction rule will not affect previously redacted data, but new requests will no longer have this redaction applied.
</Warning>

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Redaction rule identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="sid" type="string">
  ID of the deleted redaction rule
</ResponseField>

<ResponseField name="deleted" type="boolean">
  Flag indicating the redaction rule was successfully deleted
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X DELETE "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions/red_abc123def456ghi789jkl012" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/redactions/red_abc123def456ghi789jkl012', {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const result = await response.json();
  console.log(result);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "red_abc123def456ghi789jkl012",
    "deleted": true
  }
  ```
</ResponseExample>

***

## Redaction Types

### Mask

Replaces characters with asterisks while preserving format:

* `john@example.com` → `j***@*******.com`
* `4111111111111111` → `4***********1111`

### Remove

Completely removes the field from the data:

* `{"password": "secret123"}` → `{}`

### Hash

Replaces the value with a SHA-256 hash:

* `"secret123"` → `"a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3"`

### Replace

Replaces the value with a specified replacement:

* `"secret123"` → `"[REDACTED]"` (when replacementValue is `"[REDACTED]"`)

## JSON Path Examples

<CodeGroup>
  ```json Simple Field theme={null}
  {
    "password": "secret123"
  }
  // JSON Path: $.password
  ```

  ```json Nested Object theme={null}
  {
    "user": {
      "email": "john@example.com"
    }
  }
  // JSON Path: $.user.email
  ```

  ```json Array Element theme={null}
  {
    "users": [
      {"email": "john@example.com"},
      {"email": "jane@example.com"}
    ]
  }
  // JSON Path: $.users[*].email
  ```

  ```json Multiple Levels theme={null}
  {
    "order": {
      "payment": {
        "cardNumber": "4111111111111111"
      }
    }
  }
  // JSON Path: $.order.payment.cardNumber
  ```
</CodeGroup>


# Requests
Source: https://docs.apitraffic.io/api-reference/requests

Manage and analyze API requests captured by ApiTraffic

## List Requests

<api-endpoint method="GET" />

Retrieve all requests captured in a specific bucket.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

<ParamField type="string">
  Bucket identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="hasMore" type="boolean">
  Indicates if there are more records to paginate through
</ResponseField>

<ResponseField name="records" type="array">
  <Expandable title="Request Objects">
    <ResponseField name="sid" type="string">
      Request identifier (format: `req_` followed by 27 alphanumeric characters)
    </ResponseField>

    <ResponseField name="bucketSid" type="string">
      Bucket identifier this request belongs to
    </ResponseField>

    <ResponseField name="environmentSid" type="string">
      Environment identifier (6 character alphanumeric, nullable)
    </ResponseField>

    <ResponseField name="contextSid" type="string">
      Request context identifier (nullable)
    </ResponseField>

    <ResponseField name="direction" type="string">
      Request direction: `in` (inbound) or `out` (outbound)
    </ResponseField>

    <ResponseField name="note" type="string">
      User-added notes for the request (nullable)
    </ResponseField>

    <ResponseField name="createdAt" type="string">
      ISO 8601 timestamp when request was created
    </ResponseField>

    <ResponseField name="receivedAt" type="string">
      ISO 8601 timestamp when request was received
    </ResponseField>

    <ResponseField name="firewall" type="object">
      <Expandable title="Firewall Information">
        <ResponseField name="blocked" type="boolean">
          Whether the request was blocked by firewall rules
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="request" type="object">
      <Expandable title="Request Details">
        <ResponseField name="host" type="string">
          Request host (nullable)
        </ResponseField>

        <ResponseField name="method" type="string">
          HTTP method (nullable)
        </ResponseField>

        <ResponseField name="path" type="string">
          Request path (nullable)
        </ResponseField>

        <ResponseField name="port" type="number">
          Request port (nullable)
        </ResponseField>

        <ResponseField name="url" type="string">
          Full request URL (nullable)
        </ResponseField>

        <ResponseField name="queryString" type="object">
          Query string parameters
        </ResponseField>

        <ResponseField name="headers" type="object">
          Request headers as key-value pairs
        </ResponseField>

        <ResponseField name="body" type="any">
          Request body content
        </ResponseField>

        <ResponseField name="contentType" type="string">
          Content type of the request (nullable)
        </ResponseField>

        <ResponseField name="size" type="number">
          Size of request payload in bytes (nullable)
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="response" type="object">
      <Expandable title="Response Details">
        <ResponseField name="statusCode" type="number">
          HTTP status code returned (nullable)
        </ResponseField>

        <ResponseField name="headers" type="object">
          Response headers as key-value pairs (nullable)
        </ResponseField>

        <ResponseField name="size" type="number">
          Size of response payload in bytes (nullable)
        </ResponseField>

        <ResponseField name="body" type="any">
          Response body content
        </ResponseField>

        <ResponseField name="contentType" type="string">
          Content type of the response (nullable)
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="timings" type="object">
      <Expandable title="Performance Timings">
        <ResponseField name="duration" type="number">
          Total request duration in milliseconds (nullable)
        </ResponseField>

        <ResponseField name="start" type="number">
          Request start time (nullable)
        </ResponseField>

        <ResponseField name="end" type="number">
          Request end time (nullable)
        </ResponseField>

        <ResponseField name="lookup" type="number">
          DNS lookup time (nullable)
        </ResponseField>

        <ResponseField name="socket" type="number">
          Socket assignment time (nullable)
        </ResponseField>

        <ResponseField name="upload" type="number">
          Upload completion time (nullable)
        </ResponseField>

        <ResponseField name="connect" type="number">
          Connection establishment time (nullable)
        </ResponseField>

        <ResponseField name="response" type="number">
          Response start time (nullable)
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const requests = await response.json();
  console.log(requests);
  ```

  ```python Python theme={null}
  import requests

  response = requests.get(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests',
      headers={'Authorization': 'Bearer your-jwt-token'}
  )

  requests_data = response.json()
  print(requests_data)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "hasMore": false,
    "records": [
      {
        "sid": "req_abc123def456ghi789jkl012mno",
        "bucketSid": "bkt_xyz789uvw012rst345abc",
        "environmentSid": "env123",
        "contextSid": null,
        "direction": "in",
        "note": null,
        "createdAt": "2023-12-01T10:30:00.000Z",
        "receivedAt": "2023-12-01T10:30:00.100Z",
        "firewall": {
          "blocked": false
        },
        "request": {
          "host": "api.example.com",
          "method": "GET",
          "path": "/users/123",
          "port": 443,
          "url": "https://api.example.com/users/123",
          "queryString": {},
          "headers": {
            "user-agent": "Mozilla/5.0",
            "accept": "application/json"
          },
          "body": null,
          "contentType": null,
          "size": 0
        },
        "response": {
          "statusCode": 200,
          "headers": {
            "content-type": "application/json",
            "content-length": "156"
          },
          "size": 156,
          "body": {
            "id": 123,
            "name": "John Doe",
            "email": "john@example.com"
          },
          "contentType": "application/json"
        },
        "timings": {
          "duration": 245,
          "start": 1701423000000,
          "end": 1701423000245,
          "lookup": 12,
          "socket": 25,
          "upload": 30,
          "connect": 45,
          "response": 200
        }
      }
    ]
  }
  ```
</ResponseExample>

***

## Get Request

<api-endpoint method="GET" />

Retrieve details of a specific request.

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Bucket identifier
</ParamField>

<ParamField type="string">
  Request identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

Returns a single request object with the same structure as described in the List Requests response.

<RequestExample>
  ```bash cURL theme={null}
  curl -X GET "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests/req_abc123def456ghi789jkl012mno" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests/req_abc123def456ghi789jkl012mno', {
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const request = await response.json();
  console.log(request);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "req_abc123def456ghi789jkl012mno",
    "bucketSid": "bkt_xyz789uvw012rst345abc",
    "environmentSid": "env123",
    "contextSid": null,
    "direction": "in",
    "note": null,
    "createdAt": "2023-12-01T10:30:00.000Z",
    "receivedAt": "2023-12-01T10:30:00.100Z",
    "firewall": {
      "blocked": false
    },
    "request": {
      "host": "api.example.com",
      "method": "GET",
      "path": "/users/123",
      "port": 443,
      "url": "https://api.example.com/users/123",
      "queryString": {},
      "headers": {
        "user-agent": "Mozilla/5.0",
        "accept": "application/json"
      },
      "body": null,
      "contentType": null,
      "size": 0
    },
    "response": {
      "statusCode": 200,
      "headers": {
        "content-type": "application/json",
        "content-length": "156"
      },
      "size": 156,
      "body": {
        "id": 123,
        "name": "John Doe",
        "email": "john@example.com"
      },
      "contentType": "application/json"
    },
    "timings": {
      "duration": 245,
      "start": 1701423000000,
      "end": 1701423000245,
      "lookup": 12,
      "socket": 25,
      "upload": 30,
      "connect": 45,
      "response": 200
    }
  }
  ```
</ResponseExample>

***

## Update Request

<api-endpoint method="PUT" />

Update details of a specific request (typically used to add notes or modify metadata).

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Bucket identifier
</ParamField>

<ParamField type="string">
  Request identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Add or update notes for the request
</ParamField>

### Response

Returns the updated request object.

<RequestExample>
  ```bash cURL theme={null}
  curl -X PUT "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests/req_abc123def456ghi789jkl012mno" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "note": "This request was flagged for review"
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests/req_abc123def456ghi789jkl012mno', {
    method: 'PUT',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      note: 'This request was flagged for review'
    })
  });

  const request = await response.json();
  console.log(request);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "req_abc123def456ghi789jkl012mno",
    "bucketSid": "bkt_xyz789uvw012rst345abc",
    "environmentSid": "env123",
    "contextSid": null,
    "direction": "in",
    "note": "This request was flagged for review",
    "createdAt": "2023-12-01T10:30:00.000Z",
    "receivedAt": "2023-12-01T10:30:00.100Z",
    "firewall": {
      "blocked": false
    },
    "request": {
      "host": "api.example.com",
      "method": "GET",
      "path": "/users/123",
      "port": 443,
      "url": "https://api.example.com/users/123",
      "queryString": {},
      "headers": {
        "user-agent": "Mozilla/5.0",
        "accept": "application/json"
      },
      "body": null,
      "contentType": null,
      "size": 0
    },
    "response": {
      "statusCode": 200,
      "headers": {
        "content-type": "application/json",
        "content-length": "156"
      },
      "size": 156,
      "body": {
        "id": 123,
        "name": "John Doe",
        "email": "john@example.com"
      },
      "contentType": "application/json"
    },
    "timings": {
      "duration": 245,
      "start": 1701423000000,
      "end": 1701423000245,
      "lookup": 12,
      "socket": 25,
      "upload": 30,
      "connect": 45,
      "response": 200
    }
  }
  ```
</ResponseExample>

***

## Delete Request

<api-endpoint method="DELETE" />

Delete a specific request from the bucket.

<Warning>
  This action is irreversible. The request data will be permanently deleted.
</Warning>

### Path Parameters

<ParamField type="string">
  Account identifier
</ParamField>

<ParamField type="string">
  Bucket identifier
</ParamField>

<ParamField type="string">
  Request identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Response

<ResponseField name="sid" type="string">
  ID of the deleted request
</ResponseField>

<ResponseField name="deleted" type="boolean">
  Flag indicating the request was successfully deleted
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X DELETE "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests/req_abc123def456ghi789jkl012mno" \
    -H "Authorization: Bearer your-jwt-token"
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/buckets/bkt_xyz789uvw012rst345abc/requests/req_abc123def456ghi789jkl012mno', {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer your-jwt-token'
    }
  });

  const result = await response.json();
  console.log(result);
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "req_abc123def456ghi789jkl012mno",
    "deleted": true
  }
  ```
</ResponseExample>


# Workflows
Source: https://docs.apitraffic.io/api-reference/workflows

Create and manage automated workflows based on API traffic patterns

## Create Workflow

<api-endpoint method="POST" />

Create a new automated workflow that triggers based on API traffic patterns and conditions.

### Path Parameters

<ParamField type="string">
  Account identifier (format: `acc_` followed by 27 alphanumeric characters)
</ParamField>

<ParamField type="string">
  Environment identifier (6 character alphanumeric)
</ParamField>

<ParamField type="string">
  Bucket identifier
</ParamField>

### Headers

<ParamField type="string">
  Bearer token for authentication
</ParamField>

### Request Body

<ParamField type="string">
  Name of the workflow
</ParamField>

<ParamField type="string">
  Description of what this workflow does
</ParamField>

<ParamField type="object">
  <Expandable title="Trigger Configuration">
    <ParamField type="string">
      Trigger type: `request`, `error`, `threshold`, `schedule`
    </ParamField>

    <ParamField type="array">
      Array of conditions that must be met to trigger the workflow
    </ParamField>

    <ParamField type="string">
      Cron expression for scheduled workflows (required if type is `schedule`)
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type="array">
  <Expandable title="Workflow Actions">
    <ParamField type="string">
      Action type: `webhook`, `email`, `slack`, `activepieces`
    </ParamField>

    <ParamField type="object">
      Configuration specific to the action type
    </ParamField>

    <ParamField type="number">
      Execution order for this action (default: 0)
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type="boolean">
  Whether this workflow should be active (default: true)
</ParamField>

### Response

<ResponseField name="sid" type="string">
  Unique workflow identifier
</ResponseField>

<ResponseField name="accountSid" type="string">
  Account identifier this workflow belongs to
</ResponseField>

<ResponseField name="environmentSid" type="string">
  Environment identifier
</ResponseField>

<ResponseField name="bucketSid" type="string">
  Bucket identifier this workflow is associated with
</ResponseField>

<ResponseField name="name" type="string">
  Name of the workflow
</ResponseField>

<ResponseField name="description" type="string">
  Description of the workflow
</ResponseField>

<ResponseField name="trigger" type="object">
  Trigger configuration
</ResponseField>

<ResponseField name="actions" type="array">
  Array of workflow actions
</ResponseField>

<ResponseField name="isActive" type="boolean">
  Whether the workflow is currently active
</ResponseField>

<ResponseField name="createdAt" type="string">
  ISO 8601 timestamp of workflow creation
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST "https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/environments/env123/buckets/bkt_xyz789uvw012rst345abc/workflows" \
    -H "Authorization: Bearer your-jwt-token" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Error Alert Workflow",
      "description": "Send Slack notification when error rate exceeds 5%",
      "trigger": {
        "type": "threshold",
        "conditions": [
          {
            "metric": "error_rate",
            "operator": "greater_than",
            "value": 5,
            "timeWindow": "5m"
          }
        ]
      },
      "actions": [
        {
          "type": "slack",
          "config": {
            "webhook_url": "https://hooks.slack.com/services/...",
            "channel": "#alerts",
            "message": "🚨 Error rate exceeded 5% in {{bucket.name}}"
          },
          "order": 1
        }
      ],
      "isActive": true
    }'
  ```

  ```javascript Node.js theme={null}
  const response = await fetch('https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/environments/env123/buckets/bkt_xyz789uvw012rst345abc/workflows', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-jwt-token',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      name: 'Error Alert Workflow',
      description: 'Send Slack notification when error rate exceeds 5%',
      trigger: {
        type: 'threshold',
        conditions: [
          {
            metric: 'error_rate',
            operator: 'greater_than',
            value: 5,
            timeWindow: '5m'
          }
        ]
      },
      actions: [
        {
          type: 'slack',
          config: {
            webhook_url: 'https://hooks.slack.com/services/...',
            channel: '#alerts',
            message: '🚨 Error rate exceeded 5% in {{bucket.name}}'
          },
          order: 1
        }
      ],
      isActive: true
    })
  });

  const workflow = await response.json();
  console.log(workflow);
  ```

  ```python Python theme={null}
  import requests

  response = requests.post(
      'https://api.apitraffic.io/v1/accounts/acc_abc123def456ghi789jkl012/environments/env123/buckets/bkt_xyz789uvw012rst345abc/workflows',
      headers={
          'Authorization': 'Bearer your-jwt-token',
          'Content-Type': 'application/json'
      },
      json={
          'name': 'Error Alert Workflow',
          'description': 'Send Slack notification when error rate exceeds 5%',
          'trigger': {
              'type': 'threshold',
              'conditions': [
                  {
                      'metric': 'error_rate',
                      'operator': 'greater_than',
                      'value': 5,
                      'timeWindow': '5m'
                  }
              ]
          },
          'actions': [
              {
                  'type': 'slack',
                  'config': {
                      'webhook_url': 'https://hooks.slack.com/services/...',
                      'channel': '#alerts',
                      'message': '🚨 Error rate exceeded 5% in {{bucket.name}}'
                  },
                  'order': 1
              }
          ],
          'isActive': True
      }
  )

  workflow = response.json()
  print(workflow)
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "sid": "wfl_abc123def456ghi789jkl012",
    "accountSid": "acc_abc123def456ghi789jkl012",
    "environmentSid": "env123",
    "bucketSid": "bkt_xyz789uvw012rst345abc",
    "name": "Error Alert Workflow",
    "description": "Send Slack notification when error rate exceeds 5%",
    "trigger": {
      "type": "threshold",
      "conditions": [
        {
          "metric": "error_rate",
          "operator": "greater_than",
          "value": 5,
          "timeWindow": "5m"
        }
      ]
    },
    "actions": [
      {
        "type": "slack",
        "config": {
          "webhook_url": "https://hooks.slack.com/services/...",
          "channel": "#alerts",
          "message": "🚨 Error rate exceeded 5% in {{bucket.name}}"
        },
        "order": 1
      }
    ],
    "isActive": true,
    "createdAt": "2023-12-01T15:45:00.000Z"
  }
  ```
</ResponseExample>

***

## Workflow Trigger Types

### Request Trigger

Triggers when specific requests are made to your API.

```json theme={null}
{
  "type": "request",
  "conditions": [
    {
      "path": "/api/users",
      "method": "POST",
      "statusCode": 201
    }
  ]
}
```

### Error Trigger

Triggers when errors occur in your API.

```json theme={null}
{
  "type": "error",
  "conditions": [
    {
      "statusCode": 500,
      "path": "/api/*"
    }
  ]
}
```

### Threshold Trigger

Triggers when metrics cross specified thresholds.

```json theme={null}
{
  "type": "threshold",
  "conditions": [
    {
      "metric": "response_time",
      "operator": "greater_than",
      "value": 1000,
      "timeWindow": "5m"
    }
  ]
}
```

### Schedule Trigger

Triggers on a scheduled basis using cron expressions.

```json theme={null}
{
  "type": "schedule",
  "schedule": "0 9 * * MON-FRI"
}
```

***

## Workflow Action Types

### Webhook Action

Send HTTP requests to external services.

```json theme={null}
{
  "type": "webhook",
  "config": {
    "url": "https://api.example.com/webhook",
    "method": "POST",
    "headers": {
      "Authorization": "Bearer token"
    },
    "body": {
      "message": "Alert from ApiTraffic",
      "data": "{{request.body}}"
    }
  }
}
```

### Email Action

Send email notifications.

```json theme={null}
{
  "type": "email",
  "config": {
    "to": ["admin@example.com"],
    "subject": "API Alert: {{trigger.type}}",
    "body": "An alert was triggered in bucket {{bucket.name}}"
  }
}
```

### Slack Action

Send messages to Slack channels.

```json theme={null}
{
  "type": "slack",
  "config": {
    "webhook_url": "https://hooks.slack.com/services/...",
    "channel": "#alerts",
    "message": "🚨 {{trigger.message}}",
    "username": "ApiTraffic Bot"
  }
}
```

### ActivePieces Action

Trigger ActivePieces workflows for complex automation.

```json theme={null}
{
  "type": "activepieces",
  "config": {
    "flow_id": "flow_abc123",
    "webhook_url": "https://flow.apitraffic.io/webhook/...",
    "data": {
      "request": "{{request}}",
      "response": "{{response}}"
    }
  }
}
```

***

## Template Variables

Workflows support template variables that are dynamically replaced with actual values:

### Request Variables

* `{{request.method}}` - HTTP method
* `{{request.path}}` - Request path
* `{{request.headers}}` - Request headers
* `{{request.body}}` - Request body
* `{{request.query}}` - Query parameters

### Response Variables

* `{{response.statusCode}}` - HTTP status code
* `{{response.headers}}` - Response headers
* `{{response.body}}` - Response body
* `{{response.size}}` - Response size in bytes

### Timing Variables

* `{{timings.duration}}` - Total request duration
* `{{timings.responseTime}}` - Response time

### Context Variables

* `{{bucket.name}}` - Bucket name
* `{{bucket.sid}}` - Bucket ID
* `{{account.name}}` - Account name
* `{{environment.name}}` - Environment name

### Metric Variables (for threshold triggers)

* `{{metric.value}}` - Current metric value
* `{{metric.threshold}}` - Configured threshold
* `{{metric.timeWindow}}` - Time window for the metric

***

## Common Workflow Examples

### High Error Rate Alert

```json theme={null}
{
  "name": "High Error Rate Alert",
  "trigger": {
    "type": "threshold",
    "conditions": [
      {
        "metric": "error_rate",
        "operator": "greater_than",
        "value": 10,
        "timeWindow": "5m"
      }
    ]
  },
  "actions": [
    {
      "type": "slack",
      "config": {
        "message": "🚨 Error rate is {{metric.value}}% in {{bucket.name}}"
      }
    }
  ]
}
```

### Slow Response Alert

```json theme={null}
{
  "name": "Slow Response Alert",
  "trigger": {
    "type": "threshold",
    "conditions": [
      {
        "metric": "avg_response_time",
        "operator": "greater_than",
        "value": 2000,
        "timeWindow": "10m"
      }
    ]
  },
  "actions": [
    {
      "type": "email",
      "config": {
        "subject": "Slow API Performance Alert",
        "body": "Average response time is {{metric.value}}ms"
      }
    }
  ]
}
```

### New User Registration

```json theme={null}
{
  "name": "New User Registration",
  "trigger": {
    "type": "request",
    "conditions": [
      {
        "path": "/api/users",
        "method": "POST",
        "statusCode": 201
      }
    ]
  },
  "actions": [
    {
      "type": "webhook",
      "config": {
        "url": "https://crm.example.com/webhook",
        "body": {
          "event": "user_registered",
          "user_data": "{{request.body}}"
        }
      }
    }
  ]
}
```

### Daily Summary Report

```json theme={null}
{
  "name": "Daily Summary Report",
  "trigger": {
    "type": "schedule",
    "schedule": "0 9 * * *"
  },
  "actions": [
    {
      "type": "email",
      "config": {
        "subject": "Daily API Summary for {{bucket.name}}",
        "body": "Your daily API traffic summary is ready."
      }
    }
  ]
}
```


# Development
Source: https://docs.apitraffic.io/development

Set up your local development environment

## Local Development Setup

Get your ApiTraffic development environment running locally.

### Prerequisites

* Node.js (v18+ recommended)
* npm or yarn
* Git
* Docker (optional, for containerized development)

### Installation

1. Clone the repository:

```bash theme={null}
git clone https://github.com/apitraffic/platform.git
cd platform
```

2. Install dependencies:

```bash theme={null}
npm install
```

### Development Options

#### Option 1: Full npm Development (Recommended)

Run all services locally with npm for maximum development speed:

```bash theme={null}
# Run all services concurrently
npm run dev

# Or run services individually
npm run dev:api       # API server on port 8081
npm run dev:processor # Background processor
npm run dev:relay     # Relay service on port 8082
npm run dev:ui        # UI with Vite hot reloading on port 8080
```

#### Option 2: Docker Development

Run all services in Docker with volume mounts for live reloading:

```bash theme={null}
# Using Docker Compose
docker-compose -f docker-compose.dev.yml up -d

# Or using direct Docker run
docker run -d --name apitraffic-dev \
  -p 8080:8080 -p 8081:8081 -p 8082:8082 \
  -e SERVICES=all \
  -e NODE_ENV=development \
  --env-file .env.local \
  -v $(pwd)/apps:/app/apps \
  -v $(pwd)/libs:/app/libs \
  apitraffic
```

### Environment Configuration

Create your local environment file:

```bash .env.local theme={null}
NODE_ENV=local
VITE_APP_ENV=local
DATABASE_URL=postgresql://user:pass@localhost:5432/apitraffic
API_TRAFFIC_TOKEN=your-dev-token
API_TRAFFIC_BUCKET=your-dev-bucket
```

### Available Scripts

* `npm run dev` - Start all services in development mode
* `npm run local` - Start all services with local configuration
* `npm run build` - Build all applications
* `npm run test` - Run tests
* `npm run lint` - Lint the codebase
* `npm run format` - Format code using Prettier

### Project Structure

```
apitraffic-app/
├── apps/                    # Applications
│   ├── api/                 # Main API server
│   ├── processor/           # Background processor
│   ├── relay/               # Traffic relay service
│   └── ui/                  # Frontend application
├── libs/                    # Libraries
│   ├── shared/              # Shared libraries
│   └── client-libraries/    # Client SDK libraries
└── docs/                    # Documentation
```

### Making Changes

1. Create a new branch for your feature
2. Make your changes
3. Run tests: `npm test`
4. Run linting: `npm run lint`
5. Submit a pull request

### Debugging

For VS Code debugging, use the provided launch configurations in `.vscode/launch.json`.

```bash theme={null}
# Debug specific service
npm run dev:api    # Then attach debugger to port 9229
```


# Event Markers
Source: https://docs.apitraffic.io/events

Correlate deployments, incidents, and infrastructure changes with your API traffic

## What Are Event Markers?

Event markers let you annotate your ApiTraffic dashboard with significant moments — deployments, incidents, configuration changes, scaling events — so you can visually correlate them with changes in your API's throughput, error rates, and response times.

When an event is created, it appears as a **vertical line on your Throughput and Response Time charts**, making it immediately obvious whether a deploy caused a latency spike or an incident coincided with a drop in traffic.

<Frame>
  <img alt="Event markers on dashboard charts" />
</Frame>

## Why Use Event Markers?

Without event markers, correlating API behavior changes with infrastructure events means switching between dashboards, CI/CD logs, and incident timelines. Event markers bring all of that context into one view:

* **Post-deploy verification** — Did error rates increase after the last release?
* **Incident correlation** — When did the degradation start relative to the config change?
* **Performance tracking** — Did the scaling event actually improve response times?
* **Team visibility** — Everyone on the team can see what changed and when, without digging through deploy logs.

## Event Types

| Type            | When to use                                                     |
| --------------- | --------------------------------------------------------------- |
| `deployment`    | Code releases, rollbacks, container image updates               |
| `incident`      | Outages, degradations, alerts firing                            |
| `config_change` | Feature flag toggles, environment variable updates, DNS changes |
| `scale`         | Autoscaling events, manual instance scaling, database upgrades  |
| `custom`        | Anything else worth tracking                                    |

## Creating Events

There are three ways to create events, depending on your workflow.

### From the Dashboard

Navigate to **Account → Events** in the left sidebar and click **Create Event**. This is useful for manually logging incidents or one-off events.

You can set:

* **Type** and **Name** (required)
* **Description** and **Source** (optional context)
* **Buckets** and **Environments** (scope the event or apply to all)
* **Started At** and **Ended At** (defaults to now if left blank)

### From Your CI/CD Pipeline

The most powerful use of events is **automated creation from your deployment pipeline**. By adding a single API call to the end of your deploy job, every release is automatically tracked on your charts.

You'll need:

1. Your **Account SID** (found in Account Settings)
2. An **API Token** (create one under Account → API Tokens)

Store both as secrets/environment variables in your CI/CD platform.

<CodeGroup>
  ```yaml GitHub Actions theme={null}
  name: Deploy
  on:
    push:
      branches: [main]

  jobs:
    deploy:
      runs-on: ubuntu-latest
      steps:
        - uses: actions/checkout@v4

        # ... your existing deploy steps ...

        - name: Create ApiTraffic Deploy Event
          if: success()
          run: |
            curl -s -X POST \
              "https://api.apitraffic.io/v1/accounts/${{ secrets.APITRAFFIC_ACCOUNT_SID }}/events" \
              -H "Authorization: Bearer ${{ secrets.APITRAFFIC_API_TOKEN }}" \
              -H "Content-Type: application/json" \
              -d '{
                "type": "deployment",
                "name": "${{ github.ref_name }} @ ${{ github.sha }}",
                "description": "Deployed by ${{ github.actor }}",
                "source": "github_actions",
                "metadata": {
                  "commitSha": "${{ github.sha }}",
                  "branch": "${{ github.ref_name }}",
                  "actor": "${{ github.actor }}",
                  "runId": "${{ github.run_id }}",
                  "runUrl": "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
                }
              }'
  ```

  ```yaml GitLab CI theme={null}
  deploy:
    stage: deploy
    script:
      # ... your existing deploy steps ...

      - |
        curl -s -X POST \
          "https://api.apitraffic.io/v1/accounts/${APITRAFFIC_ACCOUNT_SID}/events" \
          -H "Authorization: Bearer ${APITRAFFIC_API_TOKEN}" \
          -H "Content-Type: application/json" \
          -d "{
            \"type\": \"deployment\",
            \"name\": \"${CI_COMMIT_TAG:-$CI_COMMIT_SHORT_SHA} deploy\",
            \"description\": \"Pipeline ${CI_PIPELINE_ID} by ${GITLAB_USER_LOGIN}\",
            \"source\": \"gitlab_ci\",
            \"metadata\": {
              \"commitSha\": \"${CI_COMMIT_SHA}\",
              \"branch\": \"${CI_COMMIT_BRANCH}\",
              \"pipelineId\": \"${CI_PIPELINE_ID}\",
              \"pipelineUrl\": \"${CI_PIPELINE_URL}\"
            }
          }"
  ```

  ```groovy Jenkins (Jenkinsfile) theme={null}
  pipeline {
      agent any
      stages {
          stage('Deploy') {
              steps {
                  // ... your existing deploy steps ...
              }
          }
      }
      post {
          success {
              sh """
                  curl -s -X POST \
                    "https://api.apitraffic.io/v1/accounts/\${APITRAFFIC_ACCOUNT_SID}/events" \
                    -H "Authorization: Bearer \${APITRAFFIC_API_TOKEN}" \
                    -H "Content-Type: application/json" \
                    -d '{
                      "type": "deployment",
                      "name": "${env.BUILD_TAG}",
                      "description": "Build #${env.BUILD_NUMBER}",
                      "source": "jenkins",
                      "metadata": {
                        "buildNumber": "${env.BUILD_NUMBER}",
                        "jobName": "${env.JOB_NAME}",
                        "buildUrl": "${env.BUILD_URL}"
                      }
                    }'
              """
          }
      }
  }
  ```

  ```yaml CircleCI theme={null}
  version: 2.1
  jobs:
    deploy:
      docker:
        - image: cimg/base:stable
      steps:
        # ... your existing deploy steps ...

        - run:
            name: Create ApiTraffic Deploy Event
            command: |
              curl -s -X POST \
                "https://api.apitraffic.io/v1/accounts/${APITRAFFIC_ACCOUNT_SID}/events" \
                -H "Authorization: Bearer ${APITRAFFIC_API_TOKEN}" \
                -H "Content-Type: application/json" \
                -d "{
                  \"type\": \"deployment\",
                  \"name\": \"${CIRCLE_TAG:-$CIRCLE_SHA1}\",
                  \"description\": \"Job ${CIRCLE_JOB} on ${CIRCLE_BRANCH}\",
                  \"source\": \"circleci\",
                  \"metadata\": {
                    \"commitSha\": \"${CIRCLE_SHA1}\",
                    \"branch\": \"${CIRCLE_BRANCH}\",
                    \"buildUrl\": \"${CIRCLE_BUILD_URL}\"
                  }
                }"
  ```

  ```bash Generic Script theme={null}
  #!/bin/bash
  # deploy-event.sh — call this at the end of any deploy script

  ACCOUNT_SID="${APITRAFFIC_ACCOUNT_SID}"
  API_TOKEN="${APITRAFFIC_API_TOKEN}"
  EVENT_NAME="${1:-manual deploy}"

  curl -s -X POST \
    "https://api.apitraffic.io/v1/accounts/${ACCOUNT_SID}/events" \
    -H "Authorization: Bearer ${API_TOKEN}" \
    -H "Content-Type: application/json" \
    -d "{
      \"type\": \"deployment\",
      \"name\": \"${EVENT_NAME}\",
      \"source\": \"manual\",
      \"metadata\": {
        \"hostname\": \"$(hostname)\",
        \"user\": \"$(whoami)\"
      }
    }"
  ```
</CodeGroup>

### From an AI Assistant (MCP)

If you have an [MCP token](/api-reference/mcp-tokens) configured, AI assistants connected to ApiTraffic can create events using the `create_event` tool. This is useful for logging events conversationally:

> "Create a deployment event for v2.3.1 release on the production bucket"

The MCP server also exposes `list_events` for querying existing events.

## Scoping Events to Buckets & Environments

By default, events apply to **all buckets** and **all environments** (represented as `["*"]`). This means the event annotation will appear on every dashboard.

If your event only affects a specific service or environment, you can scope it:

```json theme={null}
{
  "type": "deployment",
  "name": "payments-service v1.4.2",
  "bucketSids": ["bkt_abc123def456ghi789jkl012"],
  "environmentSids": ["env_prod789uvw012rst345abc"]
}
```

Scoped events only appear on the matching bucket/environment dashboard, keeping charts clean and relevant.

<Tip>
  When using the dashboard UI to create events, toggle off "Apply to all" under Buckets or Environments to select specific targets.
</Tip>

## The Metadata Field

The `metadata` field accepts any JSON object. Use it to store context that helps you trace from a chart annotation back to the exact change:

```json theme={null}
{
  "metadata": {
    "commitSha": "a1b2c3d4e5f6",
    "branch": "main",
    "imageTag": "v2.3.1",
    "prNumber": 427,
    "prUrl": "https://github.com/org/repo/pull/427",
    "rollback": false
  }
}
```

This data is stored with the event and returned in list/get API responses, making it available for auditing and automation.

## Point-in-Time vs Duration Events

**Point-in-time events** have only a `startedAt` timestamp (or leave it blank to default to "now"). These are ideal for deploys, config changes, and scaling events — things that happen at a specific moment.

**Duration events** have both `startedAt` and `endedAt` timestamps. These are ideal for incidents:

```json theme={null}
{
  "type": "incident",
  "name": "Database connection pool exhaustion",
  "startedAt": "2024-01-15T14:00:00Z",
  "endedAt": "2024-01-15T14:45:00Z"
}
```

<Tip>
  You can create an incident event when it starts (without `endedAt`), then update it with the resolution time later using the [Update Event](/api-reference/events#update-event) API endpoint.
</Tip>

## Managing Events

Navigate to **Account → Events** in the dashboard to view, create, and delete events. The table shows:

* **Type** — color-coded badge
* **Name** — event title
* **Source** — where the event came from
* **Started At** — when it occurred
* **Actions** — delete events you no longer need

For programmatic management, see the full [Events API Reference](/api-reference/events).

## Best Practices

### Automate Everything

The most valuable events are the ones you don't have to remember to create. Add event creation to every deploy pipeline, every scaling automation, and every incident bot.

### Use Descriptive Names

Include version numbers, service names, or ticket IDs so events are meaningful at a glance on the chart:

* `payments-service v2.3.1`
* `feature-flag: dark-mode enabled`
* `INCIDENT-1234: API gateway timeout`

### Store Rich Metadata

Commit SHAs, PR links, Docker image tags, and pipeline URLs make it trivial to trace from a traffic anomaly to the exact change that caused it.

### Scope When Possible

If a deploy only touches one service, scope the event to that bucket. This keeps other dashboards uncluttered and makes the correlation signal stronger.

### Close Your Incidents

When an incident is resolved, update the event with `endedAt` and a resolution description. This creates a clear record of impact duration.

### Standardize Source Names

Pick consistent source identifiers across your team and pipelines:

| Source           | Use for                              |
| ---------------- | ------------------------------------ |
| `github_actions` | GitHub Actions workflows             |
| `gitlab_ci`      | GitLab CI/CD pipelines               |
| `jenkins`        | Jenkins jobs                         |
| `circleci`       | CircleCI workflows                   |
| `argocd`         | Argo CD sync events                  |
| `manual`         | Events created from the dashboard UI |
| `mcp`            | Events created via AI assistant      |

## What's Next?

<CardGroup>
  <Card title="Events API Reference" icon="code" href="/api-reference/events">
    Full CRUD API documentation with request/response examples
  </Card>

  <Card title="MCP Server" icon="robot" href="/integrations/mcp-server">
    Connect AI assistants to create and query events
  </Card>
</CardGroup>


# Embeddable Request Log
Source: https://docs.apitraffic.io/integrations/embed

Embed an ApiTraffic request log directly into your application — like Stripe Elements for API traffic.

Give your customers or internal teams a real-time view of API traffic without leaving your app. The embed SDK renders a fully styled, CSS-isolated request log using Web Components (Shadow DOM) — no iFrames, no style conflicts.

<Note>
  The embed feature requires an **ApiTraffic API token** on your server to generate signed embed tokens. The client-side SDK never sees your API token.
</Note>

## How It Works

```mermaid theme={null}
sequenceDiagram
    participant Browser as Client Browser
    participant Server as Your Server
    participant AT as ApiTraffic API

    Browser->>Server: GET /api/embed-token
    Server->>AT: POST /v1/accounts/{id}/embeds/token
    AT-->>Server: { token, expiresAt }
    Server-->>Browser: { token }
    Browser->>AT: GET /v1/embed/requests (Bearer token)
    AT-->>Browser: Request log data
```

1. Your **backend** calls the ApiTraffic API with your API token to generate a signed embed JWT.
2. The JWT locks in the bucket, filters, and theme — the client SDK cannot tamper with these.
3. Your **frontend** passes the JWT to the `<apitraffic-request-log>` Web Component.
4. The component fetches data directly from ApiTraffic's embed endpoints using the JWT.

## Generate an Embed Token (Server-Side)

<CodeGroup>
  ```javascript Node.js theme={null}
  const axios = require('axios');

  async function getEmbedToken(accountSid, apiToken) {
    const response = await axios.post(
      `https://api.apitraffic.io/v1/accounts/${accountSid}/embeds/token`,
      {
        bucketSid: 'your-bucket-sid',
        view: 'request-log',
        filters: {
          environmentSid: 'abc123',              // optional
          criteria: 'method == "GET"',           // optional — same filter syntax as the dashboard
          streamViewSid: 'sv_...'                // optional — use a saved stream view
        },
        ttl: 3600,                               // seconds (min 60, max 86400)
        theme: 'light'                           // 'light' | 'dark' | 'auto'
      },
      {
        headers: { Authorization: `Bearer ${apiToken}` }
      }
    );

    return response.data; // { token, expiresAt }
  }
  ```

  ```python Python theme={null}
  import requests

  def get_embed_token(account_sid, api_token):
      response = requests.post(
          f"https://api.apitraffic.io/v1/accounts/{account_sid}/embeds/token",
          json={
              "bucketSid": "your-bucket-sid",
              "view": "request-log",
              "filters": {
                  "environmentSid": "abc123",
                  "criteria": 'method == "GET"'
              },
              "ttl": 3600,
              "theme": "light"
          },
          headers={"Authorization": f"Bearer {api_token}"}
      )
      return response.json()  # { "token": "...", "expiresAt": "..." }
  ```

  ```bash cURL theme={null}
  curl -X POST "https://api.apitraffic.io/v1/accounts/acc_.../embeds/token" \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
      "bucketSid": "your-bucket-sid",
      "filters": { "criteria": "method == \"GET\"" },
      "ttl": 3600,
      "theme": "light"
    }'
  ```
</CodeGroup>

### Token Parameters

| Parameter   | Type     | Required | Default         | Description                                         |
| ----------- | -------- | -------- | --------------- | --------------------------------------------------- |
| `bucketSid` | `string` | Yes      | —               | The bucket to scope the embed to.                   |
| `view`      | `string` | No       | `'request-log'` | The embed view type.                                |
| `filters`   | `object` | No       | `{}`            | Filters locked into the token (see below).          |
| `ttl`       | `number` | No       | `3600`          | Token lifetime in seconds (60–86400).               |
| `theme`     | `string` | No       | `'light'`       | Theme preference: `'light'`, `'dark'`, or `'auto'`. |

### Filter Options

| Filter           | Type     | Description                                      |
| ---------------- | -------- | ------------------------------------------------ |
| `environmentSid` | `string` | Filter to a specific environment.                |
| `criteria`       | `string` | Search criteria string (same syntax as the API). |
| `streamViewSid`  | `string` | Use a saved stream view's filter criteria.       |

<Warning>
  Filters are **server-side only**. They are cryptographically locked into the JWT — the client SDK cannot modify, add, or remove filters. This prevents data leakage.
</Warning>

***

## Vanilla JavaScript

### Installation

<CodeGroup>
  ```bash npm theme={null}
  npm install @apitraffic/embed
  ```

  ```bash yarn theme={null}
  yarn add @apitraffic/embed
  ```

  ```bash CDN (no build step) theme={null}
  <script src="https://unpkg.com/@apitraffic/embed/dist/apitraffic-embed.iife.js"></script>
  ```
</CodeGroup>

### Basic Usage

```html theme={null}
<!-- CDN approach -->
<script src="https://unpkg.com/@apitraffic/embed/dist/apitraffic-embed.iife.js"></script>

<apitraffic-request-log id="log" theme="light"></apitraffic-request-log>

<script>
  // Fetch a token from your backend
  fetch('/api/embed-token')
    .then(res => res.json())
    .then(({ token }) => {
      document.getElementById('log').token = token;
    });
</script>
```

Or with ES module imports:

```javascript theme={null}
import '@apitraffic/embed';

const el = document.querySelector('apitraffic-request-log');
el.token = await getTokenFromYourBackend();
```

### Attributes

| Attribute     | Type     | Default                          | Description                                |
| ------------- | -------- | -------------------------------- | ------------------------------------------ |
| `token`       | `string` | —                                | **Required.** The signed embed JWT.        |
| `theme`       | `string` | `'light'`                        | `'light'`, `'dark'`, or `'auto'`.          |
| `api-url`     | `string` | `'https://api.apitraffic.io/v1'` | Override the API base URL (self-hosted).   |
| `page-size`   | `number` | `25`                             | Requests per page (1–100).                 |
| `show-detail` | `string` | `'true'`                         | Set to `'false'` to disable row expansion. |

### Events

```javascript theme={null}
const el = document.querySelector('apitraffic-request-log');

// Fires after the first successful data load
el.addEventListener('apitraffic:ready', () => {
  console.log('Request log is ready');
});

// Fires on any API error
el.addEventListener('apitraffic:error', (e) => {
  console.error('Error:', e.detail.message);
});

// Fires ~30 seconds before the token expires
el.addEventListener('apitraffic:token-expired', async () => {
  const { token } = await fetch('/api/embed-token').then(r => r.json());
  el.token = token; // component re-fetches automatically
});

// Fires when a request row is clicked
el.addEventListener('apitraffic:request-click', (e) => {
  console.log('Clicked request:', e.detail.requestSid);
});
```

***

## React

### Installation

```bash theme={null}
npm install @apitraffic/embed-react @apitraffic/embed
```

### Drop-In Component

```jsx theme={null}
import { RequestLog } from '@apitraffic/embed-react';

function ApiLog({ token }) {
  return (
    <RequestLog
      token={token}
      theme="light"
      pageSize={25}
      onTokenExpired={async () => {
        const res = await fetch('/api/embed-token');
        const { token } = await res.json();
        return token; // returning the token auto-refreshes
      }}
      onReady={() => console.log('Loaded')}
      onError={(e) => console.error(e.detail)}
      onRequestClick={(e) => console.log(e.detail.requestSid)}
    />
  );
}
```

### Props

| Prop             | Type       | Default   | Description                                |
| ---------------- | ---------- | --------- | ------------------------------------------ |
| `token`          | `string`   | —         | **Required.** The signed embed JWT.        |
| `theme`          | `string`   | `'light'` | `'light'`, `'dark'`, or `'auto'`.          |
| `apiUrl`         | `string`   | —         | Override the API base URL.                 |
| `pageSize`       | `number`   | `25`      | Requests per page.                         |
| `showDetail`     | `boolean`  | `true`    | Enable/disable expandable row detail.      |
| `onTokenExpired` | `function` | —         | Return a new token string to auto-refresh. |
| `onReady`        | `function` | —         | Fires after the first successful load.     |
| `onError`        | `function` | —         | Fires on API errors.                       |
| `onRequestClick` | `function` | —         | Fires when a row is clicked.               |

### Headless Hook

Use `useApiTrafficEmbed` when you want full control over rendering:

```jsx theme={null}
import { useApiTrafficEmbed } from '@apitraffic/embed-react';

function CustomLog({ token }) {
  const {
    requests,
    loading,
    loadingMore,
    error,
    hasMore,
    loadMore,
    refresh
  } = useApiTrafficEmbed({
    token,
    pageSize: 50,
    onTokenExpired: async () => {
      const res = await fetch('/api/embed-token');
      return (await res.json()).token;
    }
  });

  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error: {error}</p>;

  return (
    <div>
      <button onClick={refresh}>Refresh</button>
      {requests.map(req => (
        <div key={req.sid}>
          {req.request?.method} {req.request?.path} — {req.response?.statusCode}
        </div>
      ))}
      {hasMore && (
        <button onClick={loadMore} disabled={loadingMore}>
          {loadingMore ? 'Loading...' : 'Load More'}
        </button>
      )}
    </div>
  );
}
```

***

## Theming

The Web Component uses CSS custom properties for theming. Override them on the host element:

```css theme={null}
apitraffic-request-log {
  /* Typography */
  --at-font-family: 'Inter', sans-serif;
  --at-font-size: 13px;

  /* Colors */
  --at-bg-color: #ffffff;
  --at-text-color: #1f2937;
  --at-text-muted: #6b7280;
  --at-accent-color: #3b82f6;
  --at-danger-color: #ef4444;

  /* Layout */
  --at-border-color: #e5e7eb;
  --at-border-radius: 6px;
  --at-row-hover-bg: #f9fafb;
  --at-max-height: 600px;
}
```

### Available CSS Custom Properties

| Property             | Default           | Description                    |
| -------------------- | ----------------- | ------------------------------ |
| `--at-font-family`   | System font stack | Font family                    |
| `--at-font-size`     | `13px`            | Base font size                 |
| `--at-bg-color`      | `#ffffff`         | Container background           |
| `--at-text-color`    | `#1f2937`         | Primary text color             |
| `--at-text-muted`    | `#6b7280`         | Secondary/muted text           |
| `--at-accent-color`  | `#3b82f6`         | Links, buttons, GET method     |
| `--at-danger-color`  | `#ef4444`         | Errors, DELETE method          |
| `--at-border-color`  | `#e5e7eb`         | Border color                   |
| `--at-border-radius` | `6px`             | Container border radius        |
| `--at-row-hover-bg`  | `#f9fafb`         | Row hover background           |
| `--at-max-height`    | `none`            | Max height (set for scrolling) |

### Dark Mode

Set `theme="dark"` for a built-in dark theme, or `theme="auto"` to follow the user's OS preference via `prefers-color-scheme`.

***

## Token Refresh Flow

Embed tokens are short-lived by design. The SDK fires a `token-expired` event approximately 30 seconds before expiry, giving your app time to fetch a fresh token seamlessly:

```mermaid theme={null}
sequenceDiagram
    participant Component as Embed Component
    participant App as Your App
    participant Server as Your Server
    participant AT as ApiTraffic API

    Note over Component: Token expires in 30s
    Component->>App: apitraffic:token-expired event
    App->>Server: GET /api/embed-token
    Server->>AT: POST .../embeds/token
    AT-->>Server: { token, expiresAt }
    Server-->>App: { token }
    App->>Component: el.token = newToken
    Note over Component: Re-fetches data with new token
```

***

## Security

<AccordionGroup>
  <Accordion title="How are filters protected?">
    All filters (bucket, environment, criteria, stream view) are cryptographically signed into the JWT using HMAC-SHA256. The client SDK reads the token to display data but cannot modify the filters. Any tampering invalidates the signature.
  </Accordion>

  <Accordion title="Can the client access data outside the filter scope?">
    No. The embed data endpoints extract the `accountSid`, `bucketSid`, and all filters directly from the verified JWT payload. Query parameters from the client are ignored for filtering — only pagination cursors (`from`, `limit`) are accepted.
  </Accordion>

  <Accordion title="What happens if a token is stolen?">
    Tokens are short-lived (default 1 hour, max 24 hours) and scoped to a specific bucket and filter set. An attacker can only see the same data the embed was designed to show, and only until the token expires. You can also rotate the signing secret by calling the token endpoint — a new secret is auto-generated if the existing one is cleared.
  </Accordion>

  <Accordion title="Is my API token exposed to the browser?">
    No. Your API token is only used **server-side** to generate embed JWTs. The browser only ever sees the embed JWT, which cannot be used to access any other ApiTraffic API endpoints.
  </Accordion>
</AccordionGroup>

***

## API Reference

### Create Embed Token

```
POST /v1/accounts/{accountSid}/embeds/token
```

**Authentication:** Bearer token (API token)

**Request Body:**

```json theme={null}
{
  "bucketSid": "string (required)",
  "view": "request-log",
  "filters": {
    "environmentSid": "string",
    "criteria": "string",
    "streamViewSid": "string"
  },
  "ttl": 3600,
  "theme": "light"
}
```

**Response:**

```json theme={null}
{
  "token": "eyJhbGciOiJIUzI1NiJ9...",
  "expiresAt": "2025-03-17T05:27:00.000Z"
}
```

### Get Embed Requests

```
GET /v1/embed/requests?from={cursor}&limit={25}
```

**Authentication:** Bearer token (embed JWT)

### Get Embed Request Detail

```
GET /v1/embed/requests/{requestSid}
```

**Authentication:** Bearer token (embed JWT)

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="Component shows 'No requests found'">
    Verify the `bucketSid` in your token request matches a bucket that has traffic. Check that any filters aren't too restrictive.
  </Accordion>

  <Accordion title="401 errors in the browser console">
    The embed token has likely expired. Implement the `apitraffic:token-expired` event handler (or `onTokenExpired` prop in React) to auto-refresh.
  </Accordion>

  <Accordion title="Styles look wrong or are overridden">
    The component uses Shadow DOM, so your page styles should not affect it. If you see issues, ensure you're setting CSS custom properties on the `apitraffic-request-log` element itself, not inside its shadow root.
  </Accordion>

  <Accordion title="Component doesn't render">
    Ensure the SDK script or import is loaded before the element appears in the DOM. With the CDN approach, place the `<script>` tag before the component. With bundlers, ensure `import '@apitraffic/embed'` is called.
  </Accordion>
</AccordionGroup>


# Express.js
Source: https://docs.apitraffic.io/integrations/express

Monitor your Express.js APIs with ApiTraffic

## Installation

Install the Express.js integration package:

<CodeGroup>
  ```bash npm theme={null}
  npm install @apitraffic/express
  ```

  ```bash yarn theme={null}
  yarn add @apitraffic/express
  ```

  ```bash pnpm theme={null}
  pnpm add @apitraffic/express
  ```
</CodeGroup>

## Basic Setup

Add ApiTraffic middleware to your Express application:

```javascript theme={null}
const express = require('express');
const apiTraffic = require('@apitraffic/express');

const app = express();

// Add ApiTraffic middleware
app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET
}));

// Your existing routes
app.get('/api/users', (req, res) => {
  res.json({ users: [] });
});

app.listen(3000);
```

## Configuration Options

```javascript theme={null}
app.use(apiTraffic({
  token: 'your-api-token',           // Required
  bucket: 'your-bucket-id',          // Required
  ingestHost: 'ingest.apitraffic.io', // Optional
  apiHost: 'api.apitraffic.io',       // Optional
  interceptOutbound: true,            // Optional: Monitor outbound requests
  debug: false                        // Optional: Enable debug logging
}));
```

## Advanced Usage

### Custom Tagging

Add custom tags to requests for better organization:

```javascript theme={null}
app.get('/api/users/:id', (req, res) => {
  // Add custom tags
  req.apiTraffic.tag('user_id', req.params.id);
  req.apiTraffic.tag('endpoint', 'get_user');
  
  res.json({ user: { id: req.params.id } });
});
```

### Custom Traces

Add trace messages for debugging:

```javascript theme={null}
app.post('/api/users', async (req, res) => {
  req.apiTraffic.trace('Starting user creation');
  
  try {
    const user = await createUser(req.body);
    req.apiTraffic.trace('User created successfully');
    res.json(user);
  } catch (error) {
    req.apiTraffic.trace('User creation failed');
    res.status(500).json({ error: error.message });
  }
});
```

### Error Handling

ApiTraffic automatically captures errors, but you can add additional context:

```javascript theme={null}
app.use((err, req, res, next) => {
  // Add error context
  if (req.apiTraffic) {
    req.apiTraffic.tag('error_type', err.name);
    req.apiTraffic.trace(`Error occurred: ${err.message}`);
  }
  
  res.status(500).json({ error: 'Internal Server Error' });
});
```

## Environment Variables

Configure using environment variables:

```bash .env theme={null}
API_TRAFFIC_TOKEN=your-api-token
API_TRAFFIC_BUCKET=your-bucket-id
API_TRAFFIC_INGEST_HOST=ingest.apitraffic.io
API_TRAFFIC_API_HOST=api.apitraffic.io
API_TRAFFIC_INTERCEPT_OUTBOUND=true
API_TRAFFIC_DEBUG=false
```

## Middleware Order

Place ApiTraffic middleware early in your middleware stack:

```javascript theme={null}
const app = express();

// Body parsing middleware
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// ApiTraffic middleware (place after body parsing)
app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET
}));

// Authentication middleware
app.use(authMiddleware);

// Your routes
app.use('/api', apiRoutes);
```

## TypeScript Support

The package includes TypeScript definitions:

```typescript theme={null}
import express from 'express';
import apiTraffic from '@apitraffic/express';

const app = express();

app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN!,
  bucket: process.env.API_TRAFFIC_BUCKET!,
  interceptOutbound: true
}));
```

## Troubleshooting

### Common Issues

<AccordionGroup>
  <Accordion title="Middleware not capturing requests">
    Ensure ApiTraffic middleware is placed before your route handlers and after body parsing middleware.
  </Accordion>

  <Accordion title="Missing environment variables">
    Verify that `API_TRAFFIC_TOKEN` and `API_TRAFFIC_BUCKET` are set in your environment.
  </Accordion>

  <Accordion title="Outbound requests not being tracked">
    Set `interceptOutbound: true` in your configuration to enable outbound request monitoring.
  </Accordion>
</AccordionGroup>

### Debug Mode

Enable debug mode to see detailed logging:

```javascript theme={null}
app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET,
  debug: true
}));
```


# Fastify
Source: https://docs.apitraffic.io/integrations/fastify

Monitor your Fastify APIs with ApiTraffic

## Installation

Install the Fastify integration package:

<CodeGroup>
  ```bash npm theme={null}
  npm install @apitraffic/fastify
  ```

  ```bash yarn theme={null}
  yarn add @apitraffic/fastify
  ```

  ```bash pnpm theme={null}
  pnpm add @apitraffic/fastify
  ```
</CodeGroup>

<Note>
  **Node 18+ required**
</Note>

## Basic Setup

Register ApiTraffic as a plugin in your Fastify application:

```javascript theme={null}
const fastify = require('fastify')({ logger: true });
const apiTraffic = require('@apitraffic/fastify');

// Register ApiTraffic plugin
await fastify.register(apiTraffic, {
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET
});

// Your existing routes
fastify.get('/api/users', async (request, reply) => {
  return { users: [] };
});

// Start the server
const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};
start();
```

## Configuration Options

```javascript theme={null}
await fastify.register(apiTraffic, {
  token: 'your-api-token',           // Required
  bucket: 'your-bucket-id',          // Required
  ingestHost: 'ingest.apitraffic.io', // Optional
  apiHost: 'api.apitraffic.io',       // Optional
  interceptOutbound: true,            // Optional: Monitor outbound requests
  debug: false                        // Optional: Enable debug logging
});
```

### Configuration Table

| Option              | Environment Variable             | Required | Type    | Description                                    |
| ------------------- | -------------------------------- | -------- | ------- | ---------------------------------------------- |
| `token`             | `API_TRAFFIC_TOKEN`              | Yes      | String  | Ingest token from your ApiTraffic account      |
| `bucket`            | `API_TRAFFIC_BUCKET`             | Yes      | String  | Bucket ID for data organization                |
| `interceptOutbound` | `API_TRAFFIC_INTERCEPT_OUTBOUND` | No       | Boolean | Monitor outbound HTTP requests (default: true) |
| `debug`             | `API_TRAFFIC_DEBUG`              | No       | Boolean | Enable debug logging (default: false)          |

## Advanced Usage

### Custom Tagging

Add custom tags to requests for better organization and searchability:

```javascript theme={null}
fastify.get('/api/users/:id', async (request, reply) => {
  // Add custom tags
  apiTraffic.tag('user_id', request.params.id);
  apiTraffic.tag('endpoint', 'get_user');
  apiTraffic.tag('version', 'v1');
  
  const user = await getUserById(request.params.id);
  return { user };
});
```

### Request Tracing

Add trace messages for debugging and monitoring:

```javascript theme={null}
fastify.post('/api/users', async (request, reply) => {
  apiTraffic.trace('Starting user creation process');
  
  try {
    const user = await createUser(request.body);
    apiTraffic.trace('User created successfully');
    return user;
  } catch (error) {
    apiTraffic.trace(`User creation failed: ${error.message}`);
    throw error;
  }
});
```

### Error Handling

ApiTraffic automatically captures errors, but you can add additional context:

```javascript theme={null}
fastify.setErrorHandler((error, request, reply) => {
  // Add error context
  apiTraffic.tag('error_type', error.name);
  apiTraffic.trace(`Error occurred: ${error.message}`);
  
  reply.status(500).send({ error: 'Internal Server Error' });
});
```

## Environment Variables

Configure using environment variables:

```bash .env theme={null}
API_TRAFFIC_TOKEN=your-api-token
API_TRAFFIC_BUCKET=your-bucket-id
API_TRAFFIC_INGEST_HOST=ingest.apitraffic.io
API_TRAFFIC_API_HOST=api.apitraffic.io
API_TRAFFIC_INTERCEPT_OUTBOUND=true
API_TRAFFIC_DEBUG=false
```

## Plugin Registration Order

Register ApiTraffic early in your plugin registration sequence:

```javascript theme={null}
const fastify = require('fastify')({ logger: true });

// Register ApiTraffic plugin first
await fastify.register(apiTraffic, {
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET
});

// Register other plugins
await fastify.register(require('@fastify/cors'));
await fastify.register(require('@fastify/helmet'));

// Register routes
await fastify.register(require('./routes/users'));
```

## TypeScript Support

The package includes TypeScript definitions:

```typescript theme={null}
import Fastify from 'fastify';
import apiTraffic from '@apitraffic/fastify';

const fastify = Fastify({ logger: true });

await fastify.register(apiTraffic, {
  token: process.env.API_TRAFFIC_TOKEN!,
  bucket: process.env.API_TRAFFIC_BUCKET!,
  interceptOutbound: true
});
```

## Security Features

### Data Redaction

ApiTraffic automatically redacts sensitive data based on your account settings. No code changes required - configure redaction rules in your ApiTraffic dashboard.

### Request Exclusions

Exclude specific endpoints from monitoring by configuring exclusion rules in your ApiTraffic account. Common exclusions include:

* Health check endpoints
* Static asset requests
* Internal monitoring endpoints

## Troubleshooting

<AccordionGroup>
  <Accordion title="Plugin not capturing requests">
    Ensure ApiTraffic is registered before your route handlers and other plugins that might interfere with request processing.
  </Accordion>

  <Accordion title="Missing environment variables">
    Verify that `API_TRAFFIC_TOKEN` and `API_TRAFFIC_BUCKET` are set in your environment.
  </Accordion>

  <Accordion title="Outbound requests not being tracked">
    Set `interceptOutbound: true` in your plugin options to enable outbound request monitoring.
  </Accordion>

  <Accordion title="High memory usage">
    If you're experiencing high memory usage, consider adjusting the sampling rate in your ApiTraffic account settings.
  </Accordion>
</AccordionGroup>

### Debug Mode

Enable debug mode to see detailed logging:

```javascript theme={null}
await fastify.register(apiTraffic, {
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET,
  debug: true
});
```

## Sample Application

A complete working example is available in the [GitHub repository](https://github.com/apitraffic/apitraffic-fastify/tree/master/examples/basic).

## Next Steps

<CardGroup>
  <Card title="Dashboard" icon="chart-line" href="https://app.apitraffic.io">
    View your API traffic data and analytics
  </Card>

  <Card title="Workflow Engine" icon="workflow" href="https://docs.apitraffic.io/workflow-engine">
    Create automated workflows based on your API data
  </Card>
</CardGroup>


# Hapi.js
Source: https://docs.apitraffic.io/integrations/hapi

Monitor your Hapi.js APIs with ApiTraffic

## Installation

Install the Hapi.js integration package:

<CodeGroup>
  ```bash npm theme={null}
  npm install @apitraffic/hapi
  ```

  ```bash yarn theme={null}
  yarn add @apitraffic/hapi
  ```

  ```bash pnpm theme={null}
  pnpm add @apitraffic/hapi
  ```
</CodeGroup>

<Note>
  **Node 18+ required**
</Note>

## Basic Setup

Register ApiTraffic as a plugin in your Hapi.js application:

```javascript theme={null}
const Hapi = require('@hapi/hapi');
const apiTraffic = require('@apitraffic/hapi');

const init = async () => {
  const server = Hapi.server({
    port: 3000,
    host: 'localhost'
  });

  // Register ApiTraffic plugin
  await server.register({
    plugin: apiTraffic,
    options: {
      token: process.env.API_TRAFFIC_TOKEN,
      bucket: process.env.API_TRAFFIC_BUCKET
    }
  });

  // Your existing routes
  server.route({
    method: 'GET',
    path: '/api/users',
    handler: (request, h) => {
      return { users: [] };
    }
  });

  await server.start();
  console.log('Server running on %s', server.info.uri);
};

init();
```

## Configuration Options

```javascript theme={null}
await server.register({
  plugin: apiTraffic,
  options: {
    token: 'your-api-token',           // Required
    bucket: 'your-bucket-id',          // Required
    ingestHost: 'ingest.apitraffic.io', // Optional
    apiHost: 'api.apitraffic.io',       // Optional
    interceptOutbound: true,            // Optional: Monitor outbound requests
    debug: false                        // Optional: Enable debug logging
  }
});
```

### Configuration Table

| Option              | Environment Variable             | Required | Type    | Description                                    |
| ------------------- | -------------------------------- | -------- | ------- | ---------------------------------------------- |
| `token`             | `API_TRAFFIC_TOKEN`              | Yes      | String  | Ingest token from your ApiTraffic account      |
| `bucket`            | `API_TRAFFIC_BUCKET`             | Yes      | String  | Bucket ID for data organization                |
| `interceptOutbound` | `API_TRAFFIC_INTERCEPT_OUTBOUND` | No       | Boolean | Monitor outbound HTTP requests (default: true) |
| `debug`             | `API_TRAFFIC_DEBUG`              | No       | Boolean | Enable debug logging (default: false)          |

## Advanced Usage

### Custom Tagging

Add custom tags to requests for better organization and searchability:

```javascript theme={null}
server.route({
  method: 'GET',
  path: '/api/users/{id}',
  handler: (request, h) => {
    // Add custom tags
    apiTraffic.tag('user_id', request.params.id);
    apiTraffic.tag('endpoint', 'get_user');
    apiTraffic.tag('version', 'v1');
    
    const user = getUserById(request.params.id);
    return { user };
  }
});
```

### Request Tracing

Add trace messages for debugging and monitoring:

```javascript theme={null}
server.route({
  method: 'POST',
  path: '/api/users',
  handler: async (request, h) => {
    apiTraffic.trace('Starting user creation process');
    
    try {
      const user = await createUser(request.payload);
      apiTraffic.trace('User created successfully');
      return user;
    } catch (error) {
      apiTraffic.trace(`User creation failed: ${error.message}`);
      throw error;
    }
  }
});
```

### Error Handling

ApiTraffic automatically captures errors, but you can add additional context:

```javascript theme={null}
server.ext('onPreResponse', (request, h) => {
  const response = request.response;
  
  if (response.isBoom) {
    // Add error context
    apiTraffic.tag('error_type', response.output.payload.error);
    apiTraffic.trace(`Error occurred: ${response.message}`);
  }
  
  return h.continue;
});
```

## Environment Variables

Configure using environment variables:

```bash .env theme={null}
API_TRAFFIC_TOKEN=your-api-token
API_TRAFFIC_BUCKET=your-bucket-id
API_TRAFFIC_INGEST_HOST=ingest.apitraffic.io
API_TRAFFIC_API_HOST=api.apitraffic.io
API_TRAFFIC_INTERCEPT_OUTBOUND=true
API_TRAFFIC_DEBUG=false
```

## Plugin Registration Order

Register ApiTraffic early in your plugin registration sequence:

```javascript theme={null}
const server = Hapi.server({ port: 3000 });

// Register ApiTraffic plugin first
await server.register({
  plugin: apiTraffic,
  options: {
    token: process.env.API_TRAFFIC_TOKEN,
    bucket: process.env.API_TRAFFIC_BUCKET
  }
});

// Register other plugins
await server.register(require('@hapi/cookie'));
await server.register(require('@hapi/bell'));

// Register routes
server.route(require('./routes/users'));
```

## TypeScript Support

The package includes TypeScript definitions:

```typescript theme={null}
import * as Hapi from '@hapi/hapi';
import * as apiTraffic from '@apitraffic/hapi';

const server = Hapi.server({ port: 3000 });

await server.register({
  plugin: apiTraffic,
  options: {
    token: process.env.API_TRAFFIC_TOKEN!,
    bucket: process.env.API_TRAFFIC_BUCKET!,
    interceptOutbound: true
  }
});
```

## Security Features

### Data Redaction

ApiTraffic automatically redacts sensitive data based on your account settings. No code changes required - configure redaction rules in your ApiTraffic dashboard.

### Request Exclusions

Exclude specific endpoints from monitoring by configuring exclusion rules in your ApiTraffic account. Common exclusions include:

* Health check endpoints
* Static asset requests
* Internal monitoring endpoints

## Troubleshooting

<AccordionGroup>
  <Accordion title="Plugin not capturing requests">
    Ensure ApiTraffic is registered before your route handlers and other plugins that might interfere with request processing.
  </Accordion>

  <Accordion title="Missing environment variables">
    Verify that `API_TRAFFIC_TOKEN` and `API_TRAFFIC_BUCKET` are set in your environment.
  </Accordion>

  <Accordion title="Outbound requests not being tracked">
    Set `interceptOutbound: true` in your plugin options to enable outbound request monitoring.
  </Accordion>

  <Accordion title="Plugin registration errors">
    Make sure you're using the correct plugin registration syntax for your version of Hapi.js.
  </Accordion>
</AccordionGroup>

### Debug Mode

Enable debug mode to see detailed logging:

```javascript theme={null}
await server.register({
  plugin: apiTraffic,
  options: {
    token: process.env.API_TRAFFIC_TOKEN,
    bucket: process.env.API_TRAFFIC_BUCKET,
    debug: true
  }
});
```

## Sample Application

A complete working example is available in the [GitHub repository](https://github.com/apitraffic/apitraffic-hapi/tree/master/examples/basic).

## Next Steps

<CardGroup>
  <Card title="Dashboard" icon="chart-line" href="https://app.apitraffic.io">
    View your API traffic data and analytics
  </Card>

  <Card title="Workflow Engine" icon="workflow" href="https://docs.apitraffic.io/workflow-engine">
    Create automated workflows based on your API data
  </Card>
</CardGroup>


# Koa.js
Source: https://docs.apitraffic.io/integrations/koa

Monitor your Koa.js APIs with ApiTraffic

## Installation

Install the Koa.js integration package:

<CodeGroup>
  ```bash npm theme={null}
  npm install @apitraffic/koa
  ```

  ```bash yarn theme={null}
  yarn add @apitraffic/koa
  ```

  ```bash pnpm theme={null}
  pnpm add @apitraffic/koa
  ```
</CodeGroup>

<Note>
  **Node 18+ required**
</Note>

## Basic Setup

Add ApiTraffic middleware to your Koa.js application:

```javascript theme={null}
const Koa = require('koa');
const apiTraffic = require('@apitraffic/koa');

const app = new Koa();

// Add ApiTraffic middleware
app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET
}));

// Your existing routes
app.use(async (ctx, next) => {
  if (ctx.path === '/api/users') {
    ctx.body = { users: [] };
  } else {
    await next();
  }
});

app.listen(3000);
```

## Configuration Options

```javascript theme={null}
app.use(apiTraffic({
  token: 'your-api-token',           // Required
  bucket: 'your-bucket-id',          // Required
  ingestHost: 'ingest.apitraffic.io', // Optional
  apiHost: 'api.apitraffic.io',       // Optional
  interceptOutbound: true,            // Optional: Monitor outbound requests
  debug: false                        // Optional: Enable debug logging
}));
```

### Configuration Table

| Option              | Environment Variable             | Required | Type    | Description                                    |
| ------------------- | -------------------------------- | -------- | ------- | ---------------------------------------------- |
| `token`             | `API_TRAFFIC_TOKEN`              | Yes      | String  | Ingest token from your ApiTraffic account      |
| `bucket`            | `API_TRAFFIC_BUCKET`             | Yes      | String  | Bucket ID for data organization                |
| `interceptOutbound` | `API_TRAFFIC_INTERCEPT_OUTBOUND` | No       | Boolean | Monitor outbound HTTP requests (default: true) |
| `debug`             | `API_TRAFFIC_DEBUG`              | No       | Boolean | Enable debug logging (default: false)          |

## Advanced Usage

### Custom Tagging

Add custom tags to requests for better organization and searchability:

```javascript theme={null}
const Router = require('@koa/router');
const router = new Router();

router.get('/api/users/:id', async (ctx) => {
  // Add custom tags
  apiTraffic.tag('user_id', ctx.params.id);
  apiTraffic.tag('endpoint', 'get_user');
  apiTraffic.tag('version', 'v1');
  
  const user = await getUserById(ctx.params.id);
  ctx.body = { user };
});

app.use(router.routes());
```

### Request Tracing

Add trace messages for debugging and monitoring:

```javascript theme={null}
router.post('/api/users', async (ctx) => {
  apiTraffic.trace('Starting user creation process');
  
  try {
    const user = await createUser(ctx.request.body);
    apiTraffic.trace('User created successfully');
    ctx.body = user;
  } catch (error) {
    apiTraffic.trace(`User creation failed: ${error.message}`);
    throw error;
  }
});
```

### Error Handling

ApiTraffic automatically captures errors, but you can add additional context:

```javascript theme={null}
app.on('error', (err, ctx) => {
  // Add error context
  apiTraffic.tag('error_type', err.name);
  apiTraffic.trace(`Error occurred: ${err.message}`);
  
  console.error('Server error:', err);
});

// Error handling middleware
app.use(async (ctx, next) => {
  try {
    await next();
  } catch (err) {
    ctx.status = err.statusCode || err.status || 500;
    ctx.body = { error: 'Internal Server Error' };
    ctx.app.emit('error', err, ctx);
  }
});
```

## Environment Variables

Configure using environment variables:

```bash .env theme={null}
API_TRAFFIC_TOKEN=your-api-token
API_TRAFFIC_BUCKET=your-bucket-id
API_TRAFFIC_INGEST_HOST=ingest.apitraffic.io
API_TRAFFIC_API_HOST=api.apitraffic.io
API_TRAFFIC_INTERCEPT_OUTBOUND=true
API_TRAFFIC_DEBUG=false
```

## Middleware Order

Place ApiTraffic middleware early in your middleware stack:

```javascript theme={null}
const Koa = require('koa');
const bodyParser = require('koa-bodyparser');
const cors = require('@koa/cors');
const apiTraffic = require('@apitraffic/koa');

const app = new Koa();

// Error handling middleware (first)
app.use(async (ctx, next) => {
  try {
    await next();
  } catch (err) {
    ctx.status = 500;
    ctx.body = { error: 'Internal Server Error' };
  }
});

// CORS middleware
app.use(cors());

// Body parser middleware
app.use(bodyParser());

// ApiTraffic middleware (after body parsing)
app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET
}));

// Your application routes
app.use(router.routes());
```

## TypeScript Support

The package includes TypeScript definitions:

```typescript theme={null}
import Koa from 'koa';
import apiTraffic from '@apitraffic/koa';

const app = new Koa();

app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN!,
  bucket: process.env.API_TRAFFIC_BUCKET!,
  interceptOutbound: true
}));
```

## With Koa Router

Using ApiTraffic with `@koa/router`:

```javascript theme={null}
const Koa = require('koa');
const Router = require('@koa/router');
const apiTraffic = require('@apitraffic/koa');

const app = new Koa();
const router = new Router();

// Add ApiTraffic middleware
app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET
}));

// Define routes
router.get('/api/users', async (ctx) => {
  apiTraffic.tag('endpoint', 'list_users');
  ctx.body = { users: [] };
});

router.post('/api/users', async (ctx) => {
  apiTraffic.tag('endpoint', 'create_user');
  apiTraffic.trace('Creating new user');
  
  const user = await createUser(ctx.request.body);
  ctx.body = user;
});

app.use(router.routes());
app.use(router.allowedMethods());
```

## Security Features

### Data Redaction

ApiTraffic automatically redacts sensitive data based on your account settings. No code changes required - configure redaction rules in your ApiTraffic dashboard.

### Request Exclusions

Exclude specific endpoints from monitoring by configuring exclusion rules in your ApiTraffic account. Common exclusions include:

* Health check endpoints
* Static asset requests
* Internal monitoring endpoints

## Troubleshooting

<AccordionGroup>
  <Accordion title="Middleware not capturing requests">
    Ensure ApiTraffic middleware is placed before your route handlers and after body parsing middleware.
  </Accordion>

  <Accordion title="Missing environment variables">
    Verify that `API_TRAFFIC_TOKEN` and `API_TRAFFIC_BUCKET` are set in your environment.
  </Accordion>

  <Accordion title="Outbound requests not being tracked">
    Set `interceptOutbound: true` in your configuration to enable outbound request monitoring.
  </Accordion>

  <Accordion title="Context not available in routes">
    Make sure you're using async/await syntax and that ApiTraffic middleware is properly registered.
  </Accordion>
</AccordionGroup>

### Debug Mode

Enable debug mode to see detailed logging:

```javascript theme={null}
app.use(apiTraffic({
  token: process.env.API_TRAFFIC_TOKEN,
  bucket: process.env.API_TRAFFIC_BUCKET,
  debug: true
}));
```

## Sample Application

A complete working example is available in the [GitHub repository](https://github.com/apitraffic/apitraffic-koa/tree/master/examples/basic).

## Next Steps

<CardGroup>
  <Card title="Dashboard" icon="chart-line" href="https://app.apitraffic.io">
    View your API traffic data and analytics
  </Card>

  <Card title="Workflow Engine" icon="workflow" href="https://docs.apitraffic.io/workflow-engine">
    Create automated workflows based on your API data
  </Card>
</CardGroup>


# MCP Server
Source: https://docs.apitraffic.io/integrations/mcp-server

Connect AI assistants like Claude, Cursor, and Windsurf to your ApiTraffic data via the Model Context Protocol

## Overview

ApiTraffic exposes a built-in **MCP (Model Context Protocol)** server that allows AI assistants to securely query your API traffic data. This enables AI-powered debugging, analytics, and monitoring workflows directly from tools like Claude Desktop, Cursor, Windsurf, VS Code, and any other MCP-compatible client.

<Info>
  MCP tokens are scoped to a specific environment and set of buckets — AI assistants can only access the data you explicitly allow.
</Info>

## Available Tools

When connected, the MCP server exposes the following tools to AI assistants:

### Request & Metrics Tools

| Tool                 | Description                                                                                 |
| -------------------- | ------------------------------------------------------------------------------------------- |
| `search_requests`    | Search API request logs with filtering by method, status code, time range, and query string |
| `get_metrics`        | Get summary metrics: total requests, average response time, error count, and blocked count  |
| `get_errors`         | List requests that returned 4xx or 5xx status codes                                         |
| `get_request_detail` | Get full details for a single request including headers, body, and response                 |
| `get_throughput`     | Get request throughput time series broken down by status code range (2xx, 3xx, 4xx, 5xx)    |
| `get_response_times` | Get response time percentiles (p50, p95, p99) and averages over time                        |

### Configuration Tools

| Tool                | Description                                                                          |
| ------------------- | ------------------------------------------------------------------------------------ |
| `list_buckets`      | List the buckets the MCP token has access to                                         |
| `list_environments` | List environments configured for the account (e.g. production, staging, development) |
| `list_redactions`   | List data redaction rules that mask sensitive data from captured requests            |
| `list_exclusions`   | List exclusion rules that prevent matching requests from being captured              |

### Event Tools

| Tool           | Description                                                                                |
| -------------- | ------------------------------------------------------------------------------------------ |
| `list_events`  | List event markers (deployments, incidents, config changes) to correlate with traffic data |
| `create_event` | Create an event marker to correlate with API traffic (e.g. deployments, incidents)         |

## Quick Start

### 1. Create an MCP Token

Navigate to **Settings → MCP Tokens** in the ApiTraffic dashboard and create a new token. Select the environment and buckets you want the AI assistant to access.

<Warning>
  The token value is only shown once at creation. Copy it immediately and store it securely.
</Warning>

### 2. Configure Your AI Client

<CodeGroup>
  ```json Windsurf theme={null}
  {
    "mcpServers": {
      "apitraffic": {
        "serverUrl": "https://api.apitraffic.io/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_MCP_TOKEN"
        }
      }
    }
  }
  ```

  ```json Cursor theme={null}
  {
    "mcpServers": {
      "apitraffic": {
        "url": "https://api.apitraffic.io/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_MCP_TOKEN"
        }
      }
    }
  }
  ```

  ```json Claude Desktop theme={null}
  {
    "mcpServers": {
      "apitraffic": {
        "url": "https://api.apitraffic.io/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_MCP_TOKEN"
        }
      }
    }
  }
  ```

  ```json VS Code / Copilot theme={null}
  {
    "servers": {
      "apitraffic": {
        "type": "http",
        "url": "https://api.apitraffic.io/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_MCP_TOKEN"
        }
      }
    }
  }
  ```
</CodeGroup>

<Info>
  **Config file locations:**

  * **Windsurf**: `~/.codeium/windsurf/mcp_config.json`
  * **Cursor**: `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project)
  * **Claude Desktop**: `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)
  * **VS Code**: `.vscode/mcp.json` (project)
</Info>

### 3. Start Querying

Once connected, you can ask your AI assistant questions like:

* *"Show me the most recent API errors in production"*
* *"What's the average response time for the last hour?"*
* *"Search for all POST requests to /api/users that returned 500"*
* *"Give me throughput metrics for the past 24 hours"*
* *"List my environments and redaction rules"*
* *"Create a deployment event for v2.3.1"*

## Transport Protocols

ApiTraffic supports two MCP transport protocols:

### Streamable HTTP (Recommended)

The primary transport with stateful session management. Sessions persist across requests using the `mcp-session-id` header and are backed by Redis for multi-instance reliability.

* **Endpoint**: `POST https://api.apitraffic.io/mcp`
* **Auth**: `Authorization: Bearer YOUR_MCP_TOKEN` header
* **Session**: Automatic via `mcp-session-id` response header

### SSE (Server-Sent Events)

Legacy transport maintained for backward compatibility with older MCP clients.

* **Endpoint**: `GET https://api.apitraffic.io/mcp/sse`
* **Message Endpoint**: `POST https://api.apitraffic.io/mcp/sse/message`
* **Auth**: `Authorization: Bearer YOUR_MCP_TOKEN` header

## Security

* **Scoped access** — MCP tokens are read-only for traffic data; the only write operation is `create_event`
* **Environment scoped** — Each token is locked to a single environment
* **Bucket scoped** — Tokens can be restricted to specific buckets or granted access to all buckets in the environment
* **Instant revocation** — Revoking a token immediately terminates access
* **No cross-tenant leakage** — Token context is enforced on every tool call
* **Session isolation** — Each MCP session is isolated with its own server instance

## Example Interactions

### Searching for Errors

Ask your AI assistant:

> *"Find all 500 errors in the last 2 hours and show me the request details"*

The assistant will use `get_errors` to find matching requests, then `get_request_detail` to retrieve full request/response bodies for debugging.

### Monitoring Performance

> *"What are the p95 response times for my API over the last day? Are there any anomalies?"*

The assistant will use `get_response_times` and `get_throughput` to analyze performance patterns and identify spikes.

### Investigating Issues

> *"Search for all requests from user-agent containing 'bot' that returned 429 status codes"*

The assistant will use `search_requests` with the appropriate filters to find rate-limited bot traffic.

### Tracking Deployments

> *"Create a deployment event for version 2.3.1 released from GitHub Actions"*

The assistant will use `create_event` to create a marker that correlates with your traffic metrics, making it easy to spot regressions.

### Reviewing Configuration

> *"Show me all my redaction rules and exclusions"*

The assistant will use `list_redactions` and `list_exclusions` to display your data protection and traffic filtering configuration.


# Integration Overview
Source: https://docs.apitraffic.io/integrations/overview

Choose the right ApiTraffic integration for your framework

## Supported Frameworks

ApiTraffic provides native integrations for popular Node.js frameworks. Each integration is designed to work seamlessly with your existing application architecture.

<CardGroup>
  <Card title="Express.js" icon="node-js" href="/integrations/express">
    The most popular Node.js web framework
  </Card>

  <Card title="Fastify" icon="bolt" href="/integrations/fastify">
    Fast and low overhead web framework
  </Card>

  <Card title="Hapi.js" icon="server" href="/integrations/hapi">
    Rich framework for building applications and services
  </Card>

  <Card title="Koa.js" icon="leaf" href="/integrations/koa">
    Next generation web framework for Node.js
  </Card>
</CardGroup>

## CMS Integrations

<Card title="Strapi" icon="database" href="/integrations/strapi">
  Open-source headless CMS integration
</Card>

## Installation

All integrations are available via npm:

<CodeGroup>
  ```bash Express theme={null}
  npm install @apitraffic/express
  ```

  ```bash Fastify theme={null}
  npm install @apitraffic/fastify
  ```

  ```bash Hapi theme={null}
  npm install @apitraffic/hapi
  ```

  ```bash Koa theme={null}
  npm install @apitraffic/koa
  ```
</CodeGroup>

## Common Configuration

All integrations share the same configuration options:

```javascript theme={null}
{
  token: 'your-api-token',           // Required: Your ApiTraffic API token
  bucket: 'your-bucket-id',          // Required: Your bucket identifier
  ingestHost: 'ingest.apitraffic.io', // Optional: Custom ingest endpoint
  apiHost: 'api.apitraffic.io',       // Optional: Custom API endpoint
  interceptOutbound: true,            // Optional: Monitor outbound requests
  debug: false                        // Optional: Enable debug logging
}
```

## Environment Variables

You can also configure using environment variables:

```bash theme={null}
API_TRAFFIC_TOKEN=your-api-token
API_TRAFFIC_BUCKET=your-bucket-id
API_TRAFFIC_INGEST_HOST=ingest.apitraffic.io
API_TRAFFIC_API_HOST=api.apitraffic.io
API_TRAFFIC_INTERCEPT_OUTBOUND=true
API_TRAFFIC_DEBUG=false
```

## Features

All integrations provide:

* **Request/Response Monitoring** - Automatic capture of HTTP requests and responses
* **Outbound Request Tracking** - Monitor external API calls your application makes
* **Error Tracking** - Capture and analyze application errors
* **Performance Metrics** - Response times, throughput, and performance insights
* **Custom Tagging** - Add custom metadata to requests for better organization
* **Data Redaction** - Automatically redact sensitive information

## Getting Started

1. Choose your framework integration
2. Install the package
3. Add the middleware/plugin to your application
4. Configure with your API credentials
5. Start monitoring your API traffic

<Note>
  Need help choosing? Express.js is the most widely used and has the most comprehensive documentation and examples.
</Note>


# Strapi
Source: https://docs.apitraffic.io/integrations/strapi

Monitor your Strapi CMS APIs with ApiTraffic

## Installation

Install the Strapi integration package:

<CodeGroup>
  ```bash npm theme={null}
  npm install @apitraffic/strapi
  ```

  ```bash yarn theme={null}
  yarn add @apitraffic/strapi
  ```

  ```bash pnpm theme={null}
  pnpm add @apitraffic/strapi
  ```
</CodeGroup>

<Note>
  **Node 18+ required**
</Note>

## Setup

### 1. Install the Plugin

Add the ApiTraffic plugin to your Strapi application:

```bash theme={null}
npm install @apitraffic/strapi --save
```

### 2. Add to Middlewares Configuration

The middleware must be added to the `config/middlewares.js` file:

```javascript theme={null}
module.exports = [
  'strapi::logger',
  'strapi::errors',
  'strapi::security',
  'strapi::cors',
  'strapi::poweredBy',
  'strapi::query',
  'strapi::body',
  'strapi::session',
  'strapi::favicon',
  'strapi::public',
  // Add ApiTraffic middleware
  'plugin::apitraffic.apitraffic',
];
```

### 3. Environment Configuration

Add the required environment variables to your `.env` file:

```bash .env theme={null}
API_TRAFFIC_TOKEN=your-api-token
API_TRAFFIC_BUCKET=your-bucket-id
```

## Configuration

### Required Environment Variables

| Environment Variable | Required | Type   | Description                               |
| -------------------- | -------- | ------ | ----------------------------------------- |
| `API_TRAFFIC_TOKEN`  | Yes      | String | Ingest token from your ApiTraffic account |
| `API_TRAFFIC_BUCKET` | Yes      | String | Bucket ID for data organization           |

### Optional Configuration

You can also configure additional options by creating a plugin configuration file at `config/plugins.js`:

```javascript theme={null}
module.exports = {
  'apitraffic': {
    enabled: true,
    config: {
      token: process.env.API_TRAFFIC_TOKEN,
      bucket: process.env.API_TRAFFIC_BUCKET,
      interceptOutbound: true,
      debug: false
    }
  }
};
```

## Features

### Automatic API Monitoring

Once installed, ApiTraffic automatically monitors:

* **Content API requests** - All requests to your Strapi content endpoints
* **Admin API requests** - Administrative operations and user management
* **Custom API routes** - Any custom routes you've added to your Strapi application
* **Plugin API calls** - Requests to installed plugin endpoints

### Workflow Integration

ApiTraffic's workflow engine allows you to create automated workflows that trigger based on your Strapi API activity:

* **Content Creation Workflows** - Trigger actions when new content is created
* **User Registration Flows** - Automate user onboarding processes
* **Data Synchronization** - Sync content changes with external systems
* **Notification Systems** - Send alerts based on API usage patterns

### Real-time Analytics

Monitor your Strapi application with comprehensive analytics:

* Request volume and patterns
* Response times and performance metrics
* Error rates and debugging information
* User activity and content usage statistics

## Security Features

### Data Redaction

ApiTraffic automatically redacts sensitive data based on your account settings. Configure redaction rules in your ApiTraffic dashboard to protect:

* User passwords and authentication tokens
* Personal identifiable information (PII)
* Payment and financial data
* Custom sensitive fields

### Request Exclusions

Exclude specific endpoints from monitoring by configuring exclusion rules in your ApiTraffic account. Common exclusions for Strapi include:

* Health check endpoints (`/_health`)
* Static asset requests
* Admin panel assets
* Internal monitoring endpoints

## Advanced Usage

### Custom Tagging

While Strapi doesn't support direct tagging in middleware, you can add custom tags through controller extensions:

```javascript theme={null}
// In your custom controller
module.exports = {
  async find(ctx) {
    // Add custom context through Strapi's built-in logging
    strapi.log.info('Custom operation', {
      userId: ctx.state.user?.id,
      contentType: 'articles'
    });
    
    return await super.find(ctx);
  }
};
```

### Webhook Integration

Combine ApiTraffic with Strapi webhooks for comprehensive monitoring:

```javascript theme={null}
// config/plugins.js
module.exports = {
  'apitraffic': {
    enabled: true,
    config: {
      token: process.env.API_TRAFFIC_TOKEN,
      bucket: process.env.API_TRAFFIC_BUCKET
    }
  },
  'webhooks': {
    enabled: true,
    config: {
      // Configure webhooks to work alongside ApiTraffic
    }
  }
};
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="Plugin not capturing requests">
    Ensure the ApiTraffic middleware is properly added to your `config/middlewares.js` file and placed in the correct order.
  </Accordion>

  <Accordion title="Missing environment variables">
    Verify that `API_TRAFFIC_TOKEN` and `API_TRAFFIC_BUCKET` are set in your `.env` file and that Strapi is loading them correctly.
  </Accordion>

  <Accordion title="Plugin not loading">
    Check that the plugin is properly installed and that your `package.json` includes `@apitraffic/strapi` in dependencies.
  </Accordion>

  <Accordion title="Performance issues">
    If you're experiencing performance issues, consider adjusting the sampling rate in your ApiTraffic account settings.
  </Accordion>
</AccordionGroup>

### Debug Mode

Enable debug logging by setting the debug flag in your plugin configuration:

```javascript theme={null}
// config/plugins.js
module.exports = {
  'apitraffic': {
    enabled: true,
    config: {
      token: process.env.API_TRAFFIC_TOKEN,
      bucket: process.env.API_TRAFFIC_BUCKET,
      debug: true
    }
  }
};
```

## Strapi Marketplace

The ApiTraffic plugin is available on the [Strapi Marketplace](https://market.strapi.io/plugins/@apitraffic-strapi) for easy discovery and installation.

## Use Cases

### Content Management Monitoring

* Track content creation, updates, and deletions
* Monitor user engagement with different content types
* Analyze API usage patterns for optimization

### Performance Optimization

* Identify slow-performing endpoints
* Monitor database query performance
* Track memory and CPU usage patterns

### Security Monitoring

* Detect unusual API access patterns
* Monitor authentication failures
* Track admin panel usage

### Integration Workflows

* Automatically sync content with external systems
* Trigger email campaigns based on content changes
* Update search indexes when content is modified

## Next Steps

<CardGroup>
  <Card title="Dashboard" icon="chart-line" href="https://app.apitraffic.io">
    View your Strapi API traffic data and analytics
  </Card>

  <Card title="Workflow Engine" icon="workflow" href="https://docs.apitraffic.io/workflow-engine">
    Create automated workflows based on your Strapi data
  </Card>

  <Card title="Strapi Marketplace" icon="store" href="https://market.strapi.io/plugins/@apitraffic-strapi">
    View the plugin on Strapi Marketplace
  </Card>

  <Card title="Sample Applications" icon="code" href="https://github.com/apitraffic/apitraffic-strapi">
    Explore example implementations
  </Card>
</CardGroup>


# Introduction
Source: https://docs.apitraffic.io/introduction

Welcome to ApiTraffic - The complete API monitoring and analytics platform

## What is ApiTraffic?

ApiTraffic is a comprehensive API monitoring and analytics platform that helps developers and teams understand, optimize, and secure their API traffic. Built as a modern microservices architecture, ApiTraffic provides real-time insights into your API performance, usage patterns, and potential issues.

## Key Features

<CardGroup>
  <Card title="Real-time Monitoring" icon="chart-line" href="/essentials/monitoring">
    Monitor your API traffic in real-time with detailed metrics and analytics
  </Card>

  <Card title="Framework Integrations" icon="plug" href="/integrations/overview">
    Easy integration with Express, Fastify, Hapi, Koa, and Strapi
  </Card>

  <Card title="Traffic Analytics" icon="chart-bar" href="/essentials/analytics">
    Deep insights into API usage patterns, performance, and user behavior
  </Card>

  <Card title="Error Tracking" icon="bug" href="/essentials/error-tracking">
    Comprehensive error tracking and debugging capabilities
  </Card>
</CardGroup>

## Architecture Overview

ApiTraffic is built as a distributed system with the following core components:

* **API Server** - Main REST API for platform management and data access
* **Processor** - Background service for processing API traffic data
* **Relay** - Traffic forwarding and routing service
* **Client Libraries** - SDK packages for various frameworks
* **UI Dashboard** - Web interface for monitoring and analytics

## Getting Started

<CardGroup>
  <Card title="Quick Start" icon="rocket" href="/quickstart">
    Get up and running with ApiTraffic in under 5 minutes
  </Card>

  <Card title="Choose Your Framework" icon="code" href="/integrations/overview">
    Find the integration guide for your preferred framework
  </Card>
</CardGroup>

## Support

Need help? We're here to support you:

* **Documentation**: Comprehensive guides and API reference
* **Community**: Join our community for discussions and support
* **Email**: Reach out to [support@apitraffic.io](mailto:support@apitraffic.io) for direct assistance


# Quickstart
Source: https://docs.apitraffic.io/quickstart

Start monitoring your APIs in under 5 minutes

## Setup your development

Learn how to update your docs locally and and deploy them to the public.

### Install ApiTraffic

<CodeGroup>
  ```bash npm theme={null}
  npm install @apitraffic/express
  ```

  ```bash yarn theme={null}
  yarn add @apitraffic/express
  ```

  ```bash pnpm theme={null}
  pnpm add @apitraffic/express
  ```
</CodeGroup>

### Configure your API

Add ApiTraffic to your Express application:

```javascript theme={null}
const express = require('express');
const apiTraffic = require('@apitraffic/express');

const app = express();

// Configure ApiTraffic
app.use(apiTraffic({
  token: 'your-api-token',
  bucket: 'your-bucket-id',
  interceptOutbound: true
}));

// Your existing routes
app.get('/api/users', (req, res) => {
  res.json({ users: [] });
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});
```

### Environment Variables

Set up your environment variables:

```bash .env theme={null}
API_TRAFFIC_TOKEN=your-api-token
API_TRAFFIC_BUCKET=your-bucket-id
API_TRAFFIC_INGEST_HOST=ingest.apitraffic.io
API_TRAFFIC_API_HOST=api.apitraffic.io
```

### Verify Installation

Start your application and make a test request:

```bash theme={null}
curl http://localhost:3000/api/users
```

Check your ApiTraffic dashboard to see the request data flowing in.

## Next Steps

<CardGroup>
  <Card title="Framework Integrations" icon="plug" href="/integrations/overview">
    Explore integrations for other frameworks like Fastify, Hapi, and Koa
  </Card>

  <Card title="Configuration Options" icon="gear" href="/essentials/settings">
    Learn about advanced configuration options and features
  </Card>
</CardGroup>