agentmail 0.1.19 → 0.2.3

package/dist/llms-full.txt

@@ -1862,6 +1862,244 @@ Here's the step-by-step logic for a polling-based conversational agent.
 </Callout>
 
 
+# IMAP & SMTP
+
+> Configure IMAP and SMTP to access your AgentMail inboxes using email clients or programmatic access.
+
+AgentMail supports standard IMAP and SMTP protocols, allowing you to connect using traditional email clients or integrate with existing systems that rely on these protocols.
+
+## What are IMAP and SMTP?
+
+**IMAP (Internet Message Access Protocol)** and **SMTP (Simple Mail Transfer Protocol)** are the standard protocols that power email communication across the internet.
+
+* **IMAP** is used to **read and manage emails**. It allows email clients to sync with a mail server, keeping your messages organized across multiple devices. When you check your inbox in Outlook or Thunderbird, you're using IMAP.
+
+* **SMTP** is used to **send emails**. When you hit "Send" on an email, SMTP handles delivering that message to the recipient's mail server.
+
+### Why Use IMAP/SMTP with AgentMail?
+
+* **Email Client Integration**: Connect Outlook, Thunderbird, Apple Mail, or any IMAP/SMTP-compatible client to your AgentMail inbox
+* **Programmatic Access**: Send and receive emails using standard libraries (like Python's `imaplib` or `smtplib`) in any programming language
+* **Legacy System Integration**: Bridge AgentMail with existing systems that only support IMAP/SMTP protocols
+* **Familiar Tooling**: Use email tools you already know during development and testing
+
+## Finding Your Credentials
+
+Before configuring IMAP or SMTP, you'll need two pieces of information from the [AgentMail Console](https://console.agentmail.to):
+
+<Steps>
+  <Step title="Get Your Inbox ID (Username)">
+    Navigate to **Dashboard → Inboxes** and find the **Inbox ID** column. Your
+    inbox ID is your inbox's email address (e.g., `myinbox@agentmail.to`). This
+    will be your username for IMAP authentication.
+  </Step>
+
+  <Step title="Get Your API Key (Password)">
+    Navigate to **Dashboard → API Keys** and create or copy an API key—this will
+    be your password.
+  </Step>
+</Steps>
+
+## IMAP Configuration
+
+Use IMAP to read emails from your AgentMail inbox.
+
+<Callout intent="warning" title="SSL/TLS Required">
+  SSL/TLS is **required** for all IMAP connections. Connections without SSL will
+  be rejected. Make sure to enable SSL/TLS in your email client settings.
+</Callout>
+
+| Setting      | Value                                           |
+| ------------ | ----------------------------------------------- |
+| **Host**     | `imap.agentmail.to`                             |
+| **Port**     | `993`                                           |
+| **Username** | Your inbox email (e.g., `myinbox@agentmail.to`) |
+| **Password** | Your API key                                    |
+| **SSL/TLS**  | **Required** (must be enabled)                  |
+
+<Callout intent="tip" title="Folder Support">
+  Currently, only the **INBOX** folder is accessible via IMAP. Other folders
+  (Sent, Drafts, Trash) are not available through IMAP. Use the [AgentMail
+  API](/introduction) for full folder access.
+</Callout>
+
+### Python IMAP Example
+
+```python
+import imaplib
+import os
+import email
+
+# Your credentials from AgentMail Console
+inbox_email = "myinbox@agentmail.to"  # From Dashboard → Inboxes
+api_key = os.getenv("AGENTMAIL_API_KEY")  # From Dashboard → API Keys
+
+# Connect with SSL (required)
+imap = imaplib.IMAP4_SSL("imap.agentmail.to", 993)
+
+try:
+    # Authenticate using inbox email as username
+    imap.login(inbox_email, api_key)
+
+    # Select INBOX (only supported folder)
+    imap.select("INBOX")
+
+    # Search for all messages
+    status, message_ids = imap.search(None, "ALL")
+
+    if status == "OK":
+        for msg_id in message_ids[0].split():
+            # Fetch message
+            status, msg_data = imap.fetch(msg_id, "(RFC822)")
+            if status == "OK":
+                email_body = msg_data[0][1]
+                message = email.message_from_bytes(email_body)
+                print(f"Subject: {message['subject']}")
+finally:
+    imap.logout()
+```
+
+### TypeScript IMAP Example
+
+```typescript
+import Imap from "imap";
+
+// Your credentials from AgentMail Console
+const inboxEmail = "myinbox@agentmail.to"; // From Dashboard → Inboxes
+const apiKey = process.env.AGENTMAIL_API_KEY!; // From Dashboard → API Keys
+
+const imap = new Imap({
+  user: inboxEmail,
+  password: apiKey,
+  host: "imap.agentmail.to",
+  port: 993,
+  tls: true, // SSL required
+});
+
+imap.once("ready", () => {
+  imap.openBox("INBOX", false, (err, box) => {
+    if (err) throw err;
+    console.log(`${box.messages.total} messages in INBOX`);
+    imap.end();
+  });
+});
+
+imap.once("error", (err: Error) => {
+  console.error("IMAP error:", err.message);
+});
+
+imap.connect();
+```
+
+## SMTP Configuration
+
+Use SMTP to send emails from your AgentMail inbox.
+
+<Callout intent="warning" title="SSL/TLS Required">
+  SSL/TLS is **required** for all SMTP connections. Connections without SSL will
+  be rejected. Make sure to enable SSL/TLS in your email client settings.
+</Callout>
+
+| Setting      | Value                          |
+| ------------ | ------------------------------ |
+| **Host**     | `smtp.agentmail.to`            |
+| **Port**     | `465`                          |
+| **Username** | agentmail                      |
+| **Password** | Your API key                   |
+| **SSL/TLS**  | **Required** (must be enabled) |
+
+<Callout intent="warning" title="From Address">
+  The "From" address in your email should match the email address of your inbox
+  (e.g., `myinbox@agentmail.to`). Using a different From address may result in
+  delivery failures.
+</Callout>
+
+### SMTP Limits
+
+* **Max recipients**: 50 per email
+* **Max message size**: 10MB
+* **Session timeout**: 30 minutes
+
+### Python SMTP Example
+
+```python
+import smtplib
+import os
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+
+# Your credentials from AgentMail Console
+inbox_email = "myinbox@agentmail.to"  # From Dashboard → Inboxes
+api_key = os.getenv("AGENTMAIL_API_KEY")  # From Dashboard → API Keys
+
+# Create message
+msg = MIMEMultipart()
+msg["Subject"] = "Hello from AgentMail"
+msg["From"] = inbox_email  # Use your inbox email as the From address
+msg["To"] = "recipient@example.com"
+msg.attach(MIMEText("This is a test email sent via SMTP.", "plain"))
+
+# Connect with SSL (required) and send
+with smtplib.SMTP_SSL("smtp.agentmail.to", 465) as server:
+    server.login(inbox_email, api_key)
+    server.send_message(msg)
+    print("Email sent successfully!")
+```
+
+### TypeScript SMTP Example
+
+```typescript
+import nodemailer from "nodemailer";
+
+// Your credentials from AgentMail Console
+const inboxEmail = "myinbox@agentmail.to"; // From Dashboard → Inboxes
+const apiKey = process.env.AGENTMAIL_API_KEY!; // From Dashboard → API Keys
+
+const transporter = nodemailer.createTransport({
+  host: "smtp.agentmail.to",
+  port: 465,
+  secure: true, // SSL required
+  auth: {
+    user: inboxEmail,
+    pass: apiKey,
+  },
+});
+
+async function sendEmail() {
+  const info = await transporter.sendMail({
+    from: inboxEmail, // Use your inbox email as the From address
+    to: "recipient@example.com",
+    subject: "Hello from AgentMail",
+    text: "This is a test email sent via SMTP.",
+  });
+  console.log("Email sent:", info.messageId);
+}
+
+sendEmail().catch(console.error);
+```
+
+## Troubleshooting
+
+| Error                   | Cause                   | Solution                                               |
+| ----------------------- | ----------------------- | ------------------------------------------------------ |
+| "Authentication failed" | Invalid credentials     | Verify your inbox email and API key from the console   |
+| "Connection refused"    | SSL not enabled         | Enable SSL/TLS in your client settings                 |
+| "Connection timeout"    | Firewall blocking ports | Ensure ports 993 (IMAP) and 465/587 (SMTP) are open    |
+| "Sender not authorized" | Wrong From address      | Use your inbox's email address as the From address     |
+| "Folder not found"      | Non-INBOX folder        | Only INBOX is supported; use the API for other folders |
+
+## When to Use IMAP/SMTP vs API
+
+| Use Case                    | Recommendation |
+| --------------------------- | -------------- |
+| Email client integration    | IMAP/SMTP      |
+| Simple programmatic sending | SMTP           |
+| Full inbox management       | API            |
+| Real-time notifications     | API (Webhooks) |
+| Access to all folders       | API            |
+| Bulk operations             | API            |
+
+
 # Using Custom Domains
 
 > A step-by-step guide to configuring your custom domain with AgentMail for enhanced branding and trust.
@@ -2574,6 +2812,10 @@ When AgentMail sends a webhook, the payload will have the following structure.
     Explore the full list of available event types and their data payloads.
   </Card>
 
+  <Card title="Verifying Webhooks" href="/webhook-verification">
+    Learn how to verify webhook signatures to secure your endpoints.
+  </Card>
+
   <Card title="Example: Event-Driven Agent" href="/github-star-agent">
     Build a fully deployable, event-driven agent that can respond to emails in
     real time.
@@ -3067,12 +3309,16 @@ To test your webhook setup:
 For production deployments:
 
 * **Use a dedicated server**: Deploy your webhook receiver to a cloud service (AWS, GCP, Heroku, etc.) instead of using ngrok
-* **Implement webhook verification**: Validate incoming requests are from AgentMail
+* **Implement webhook verification**: [Validate incoming requests](/webhook-verification) are authentically from AgentMail
 * **Add error handling**: Implement retry logic and error reporting
 * **Use async processing**: Return 200 immediately and process webhooks in background jobs
 * **Monitor webhook health**: Set up logging and alerting for failed webhook deliveries
 
 <CardGroup>
+  <Card title="Verifying Webhooks" href="/webhook-verification">
+    Learn how to verify webhook signatures for secure endpoints.
+  </Card>
+
   <Card title="Webhooks Overview" href="/overview">
     Learn more about how webhooks work and their payload structure.
   </Card>
@@ -3080,9 +3326,367 @@ For production deployments:
   <Card title="Webhook Events" href="/events">
     Explore the full list of webhook event types.
   </Card>
+</CardGroup>
+
+
+# Verifying Webhooks
+
+> Learn how to verify webhook signatures to secure your webhook endpoints and prevent spoofed requests.
+
+When building webhook receivers, it's critical to verify that incoming requests actually originate from AgentMail and haven't been tampered with. AgentMail uses [Svix](https://www.svix.com/) to deliver webhooks, which provides cryptographic signature verification.
+
+## Why Verify Webhooks?
+
+Without verification, anyone who discovers your webhook URL could send fake requests to your endpoint, potentially causing:
+
+* **Data manipulation:** Malicious actors could trigger actions based on fake events
+* **Security breaches:** Spoofed messages could inject harmful data into your systems
+* **Resource exhaustion:** Attackers could flood your endpoint with fake requests
+
+Always verify webhook signatures in production environments.
+
+## Getting Your Signing Secret
+
+Each webhook endpoint has a unique signing secret that you'll use to verify requests. You can find this secret in the AgentMail console when you create your webhook or by fetching your webhook details:
+
+<CodeBlocks>
+  ```python
+  from agentmail import AgentMail
+
+  client = AgentMail()
+
+  # Get webhook details including the signing secret
+  webhook = client.webhooks.get(webhook_id="ep_xxx")
+
+  # The secret starts with "whsec_"
+  signing_secret = webhook.secret
+  print(f"Signing secret: {signing_secret}")
+  ```
+
+  ```typescript
+  import AgentMail from "agentmail";
+
+  const client = new AgentMail();
+
+  // Get webhook details including the signing secret
+  const webhook = await client.webhooks.get("ep_xxx");
+
+  // The secret starts with "whsec_"
+  const signingSecret = webhook.secret;
+  console.log(`Signing secret: ${signingSecret}`);
+  ```
+</CodeBlocks>
+
+<Callout intent="warning" title="Keep your secret safe">
+  Store your signing secret securely in environment variables. Never commit it to version control or expose it in client-side code.
+</Callout>
+
+## Verification Headers
+
+Every webhook request from AgentMail includes three headers used for verification:
+
+| Header           | Description                                                                                   |
+| ---------------- | --------------------------------------------------------------------------------------------- |
+| `svix-id`        | Unique message identifier. Same ID is used for retries of the same message.                   |
+| `svix-timestamp` | Unix timestamp (seconds) when the message was sent.                                           |
+| `svix-signature` | Space-delimited list of signatures in the format `v1,<base64>` (e.g., `v1,abc123 v1,def456`). |
+
+## Verifying with the Svix Library (Recommended)
+
+The easiest way to verify webhooks is using the official Svix library, which handles all the cryptographic details for you.
+
+<CodeBlocks>
+  ```python
+  import os
+  from dotenv import load_dotenv
+  from flask import Flask, request
+
+  from svix.webhooks import Webhook, WebhookVerificationError
+
+  load_dotenv()
+
+  app = Flask(__name__)
+
+  secret = os.environ["AGENTMAIL_WEBHOOK_SECRET"]
+
+  @app.route('/webhooks', methods=['POST'])
+  def webhook_handler():
+      headers = request.headers
+      payload = request.get_data()
+
+      try:
+          wh = Webhook(secret)
+          msg = wh.verify(payload, headers)
+      except WebhookVerificationError as e:
+          return ('', 400)
+
+      # Do something with the message...
+
+      return ('', 204)
+
+  if __name__ == '__main__':
+      app.run(port=3000)
+
+  ```
+
+  ```typescript
+  import "dotenv/config";
+  import express, { Request, Response } from "express";
+  import { Webhook } from "svix";
+
+  const app = express();
+  const port = 3000;
+
+  const secret = process.env.AGENTMAIL_WEBHOOK_SECRET;
+
+  if (!secret) {
+    throw new Error("AGENTMAIL_WEBHOOK_SECRET environment variable is required");
+  }
+
+  app.post(
+    "/webhooks",
+    express.raw({ type: "application/json" }),
+    (req: Request, res: Response) => {
+      const payload = req.body;
+      const headers = req.headers as Record<string, string>;
+
+      try {
+        const wh = new Webhook(secret);
+        const msg = wh.verify(payload, headers);
+
+        // Do something with the message...
+        console.log("Webhook verified:", msg);
+
+        res.status(204).send();
+      } catch (err) {
+        console.error("Webhook verification failed:", err);
+        res.status(400).send();
+      }
+    }
+  );
+
+  app.listen(port, () => {
+    console.log(`Webhook server listening on port ${port}`);
+  });
+  ```
+</CodeBlocks>
+
+<Callout intent="info" title="Raw body required">
+  Signature verification requires the exact request body. If you're using body-parsing middleware (like `express.json()`), make sure to capture the raw body before parsing, or use `express.raw()` for your webhook endpoint.
+</Callout>
+
+## Testing Locally with ngrok
+
+During development, you'll need a way for AgentMail to reach your local server. [ngrok](https://ngrok.com/) creates a public URL that tunnels to your local machine.
+
+### Step 1: Save Your Webhook Server
+
+Create a webhook server file:
+
+<CodeBlocks>
+  ```python title="webhook_server.py"
+  import os
+  from dotenv import load_dotenv
+  from flask import Flask, request
+
+  from svix.webhooks import Webhook, WebhookVerificationError
+
+  load_dotenv()
+
+  app = Flask(__name__)
+
+  secret = os.environ.get("AGENTMAIL_WEBHOOK_SECRET")
+
+  @app.route('/webhooks', methods=['POST'])
+  def webhook_handler():
+      headers = request.headers
+      payload = request.get_data()
+
+      try:
+          wh = Webhook(secret)
+          msg = wh.verify(payload, headers)
+          print(f"Received event: {msg}")
+      except WebhookVerificationError as e:
+          print(f"Verification failed: {e}")
+          return ('', 400)
+
+      # Do something with the message...
+
+      return ('', 204)
+
+  if __name__ == '__main__':
+      app.run(port=3000)
+  ```
+
+  ```typescript title="webhook_server.ts"
+  import "dotenv/config";
+  import express, { Request, Response } from "express";
+  import { Webhook } from "svix";
+
+  const app = express();
+  const port = 3000;
+
+  const secret = process.env.AGENTMAIL_WEBHOOK_SECRET;
+
+  if (!secret) {
+    throw new Error("AGENTMAIL_WEBHOOK_SECRET environment variable is required");
+  }
+
+  app.post(
+    "/webhooks",
+    express.raw({ type: "application/json" }),
+    (req: Request, res: Response) => {
+      const payload = req.body;
+      const headers = req.headers as Record<string, string>;
+
+      try {
+        const wh = new Webhook(secret);
+        const msg = wh.verify(payload, headers);
+
+        // Do something with the message...
+        console.log("Webhook verified:", msg);
+
+        res.status(204).send();
+      } catch (err) {
+        console.error("Webhook verification failed:", err);
+        res.status(400).send();
+      }
+    }
+  );
+
+  app.listen(port, () => {
+    console.log(`Webhook server listening on port ${port}`);
+  });
+  ```
+</CodeBlocks>
+
+### Step 2: Install Dependencies and Run the Server
+
+<CodeBlocks>
+  ```bash title="Python"
+  pip install flask python-dotenv svix
+  python webhook_server.py
+  ```
+
+  ```bash title="TypeScript"
+  npm install express svix dotenv
+  npx ts-node webhook_server.ts
+  ```
+</CodeBlocks>
+
+You should see output like:
+
+<CodeBlocks>
+  ```bash title="Python"
+   * Serving Flask app 'webhook_server'
+   * Debug mode: off
+   * Running on http://127.0.0.1:3000
+  Press CTRL+C to quit
+  ```
+
+  ```bash title="TypeScript"
+  Webhook server listening on port 3000
+  ```
+</CodeBlocks>
+
+### Step 3: Start ngrok
+
+In a new terminal window, start ngrok to create a public tunnel to your local server:
+
+```bash
+ngrok http 3000
+```
+
+ngrok will display a forwarding URL:
+
+```
+Session Status                online
+Account                       your-email@example.com (Plan: Free)
+Version                       3.22.1
+Region                        United States (California) (us-cal-1)
+Forwarding                    https://da550b82a183.ngrok.app -> http://localhost:3000
+```
+
+Copy the `https://` forwarding URL (e.g., `https://da550b82a183.ngrok.app`).
+
+### Step 4: Add the URL to AgentMail Console
+
+1. Go to the [AgentMail Console](https://console.agentmail.to)
+2. Navigate to **Webhooks** in the sidebar
+3. Click **Create Webhook** (or edit an existing one)
+4. Paste your ngrok URL with the `/webhooks` path: `https://da550b82a183.ngrok.app/webhooks`
+5. Select the events you want to receive
+6. Save the webhook
+7. Copy the signing secret and add it to your `.env` file:
+
+```bash
+AGENTMAIL_WEBHOOK_SECRET=whsec_your_secret_here
+```
+
+### Step 5: Trigger a Test Event
+
+Send an email to one of your AgentMail inboxes, or use the console to send a test event. You should see the webhook received in your terminal:
+
+```
+127.0.0.1 - - [19/Jan/2026 16:57:20] "POST /webhooks HTTP/1.1" 204 -
+Received event: {'event_type': 'message.received', ...}
+```
+
+<Callout intent="info" title="Ready for production?">
+  ngrok is great for local development, but for production you'll need to deploy your webhook server to a hosting provider. See the next section for deployment options.
+</Callout>
+
+## Deploying to Production
+
+For production, you'll need to deploy your webhook server to a hosting provider that gives you a stable, public HTTPS URL. We recommend [Render](https://render.com/) for its simplicity and generous free tier.
+
+<Callout intent="info" title="Other hosting options">
+  You can also deploy to other platforms like [Railway](https://railway.app/), [Fly.io](https://fly.io/), [Heroku](https://heroku.com/), or any cloud provider that supports Python web applications. The key requirements are a stable public HTTPS URL and the ability to set environment variables.
+</Callout>
+
+## Best Practices
+
+<AccordionGroup>
+  <Accordion title="Always verify in production">
+    While you might skip verification during local development, always enable it in production environments. A compromised webhook endpoint can be a serious security vulnerability.
+  </Accordion>
+
+  <Accordion title="Use environment variables">
+    Never hardcode your signing secret. Use environment variables or a secrets manager:
+
+    ```python
+    import os
+    WEBHOOK_SECRET = os.environ["AGENTMAIL_WEBHOOK_SECRET"]
+    ```
+  </Accordion>
+</AccordionGroup>
+
+## Troubleshooting
+
+<AccordionGroup>
+  <Accordion title="Signature verification fails">
+    * Ensure you're using the raw request body, not a parsed/modified version
+    * Check that your signing secret is correct and matches the webhook endpoint
+    * Verify you're extracting headers correctly (they're case-insensitive)
+    * Make sure the timestamp hasn't expired (default tolerance is 5 minutes)
+  </Accordion>
+
+  <Accordion title="Missing headers">
+    If headers are missing, ensure your server/framework isn't stripping them. Some reverse proxies may need configuration to pass through custom headers.
+  </Accordion>
+
+  <Accordion title="Body parsing issues">
+    If you're using body-parsing middleware, make sure to access the raw body for verification. In Express, use `express.raw()` for your webhook route.
+  </Accordion>
+</AccordionGroup>
+
+<CardGroup>
+  <Card title="Webhook Setup" href="/webhook-setup">
+    Complete guide to setting up webhooks with ngrok.
+  </Card>
 
-  <Card title="Event-Driven Agent" href="/webhook-agent">
-    Build a complete agent that uses webhooks for real-time responses.
+  <Card title="Webhook Events" href="/events">
+    Explore all available webhook event types.
   </Card>
 </CardGroup>
 
@@ -5593,22 +6197,743 @@ Instead of generic auto-replies, craft responses based on classification:
 * `complaint` → "We're sorry to hear that. A senior support agent will contact you within 4 hours."
 * `feature-request` → "Great idea! We've added this to our product roadmap."
 
-### Example 5: Analytics Dashboard
+### Example 5: Analytics Dashboard
+
+**Scenario**: Track email metrics and trends.
+
+Build a dashboard that queries emails by labels to analyze:
+
+* **Sentiment trends**: Are customers getting happier or more frustrated?
+* **Volume by department**: Which team is handling the most emails?
+* **Response times by priority**: Are you meeting SLAs for urgent issues?
+* **Common categories**: What are customers asking about most?
+
+Use this data to identify bottlenecks, improve processes, and make data-driven decisions about staffing and product priorities.
+
+***
+
+Congratulations! You've built an AI-powered email classification system. This agent showcases how AgentMail's labeling feature can power sophisticated inbox automation and analytics.
+
+
+# Sales Agent with WebSocket
+
+> A step-by-step guide to building an AI-powered sales agent that uses WebSocket for real-time email processing without polling or webhooks.
+
+## Overview
+
+Learn how to build a real-time sales agent that processes emails instantly using WebSocket connections. Unlike webhook-based agents that require ngrok and public URLs, this WebSocket approach connects directly to AgentMail for true real-time processing with minimal setup.
+
+This agent demonstrates a practical sales workflow: a manager delegates customer outreach to the agent, which then handles the entire conversation autonomously while keeping the manager informed of key signals.
+
+## What You'll Build
+
+By the end of this guide, you'll have a working sales agent that:
+
+1. **Connects via WebSocket** for instant, real-time email processing
+2. **Handles manager emails** by extracting customer info and sending personalized outreach
+3. **Processes customer replies** with AI-powered, context-aware responses
+4. **Notifies the manager** when customers show strong buying signals
+
+Here's the workflow:
+
+```
+Manager sends email with customer info
+         ↓
+    Agent extracts customer email
+         ↓
+    Agent generates AI sales pitch → Sends to customer
+         ↓
+    Agent confirms to manager
+         ↓
+    [Customer replies]
+         ↓
+    Agent detects intent + generates AI response
+         ↓
+    If interested → Notifies manager
+```
+
+## WebSocket vs Webhook: Why WebSocket?
+
+| Feature      | Webhook Approach            | WebSocket Approach       |
+| ------------ | --------------------------- | ------------------------ |
+| Setup        | Requires ngrok + public URL | No external tools needed |
+| Architecture | Flask server + HTTP         | Pure async Python        |
+| Latency      | HTTP round-trip             | Instant streaming        |
+| Firewall     | Must expose port            | Outbound only            |
+
+For more details, see the [WebSocket API Reference](/api-reference/websockets) and the [Python SDK WebSocket documentation](https://github.com/agentmail-to/agentmail-python?tab=readme-ov-file#websockets).
+
+## Prerequisites
+
+Before you begin, make sure you have:
+
+<Callout intent="info">
+  **Required:**
+
+  * Python 3.11 or higher installed
+  * An [AgentMail account](https://console.agentmail.to) and API key
+  * An [OpenAI account](https://platform.openai.com) and API key
+</Callout>
+
+## Project Setup
+
+### Step 1: Create Project Directory
+
+Create a new directory for your agent:
+
+```bash
+mkdir sales-agent-websocket
+cd sales-agent-websocket
+```
+
+### Step 2: Create the Agent Code
+
+Create a file named `main.py` and paste the following code:
+
+<Accordion title="Click to view full main.py code">
+  ```python
+  """
+  Sales Agent using AgentMail WebSocket
+
+  This is a simple example showing how to:
+  - Connect to AgentMail via WebSocket for real-time email processing
+  - Use OpenAI to handle sales conversations
+  - Send emails to customers and respond to replies
+  """
+
+  import asyncio
+  import os
+  import re
+  from dotenv import load_dotenv
+  from agentmail import AsyncAgentMail, Subscribe, Subscribed, MessageReceivedEvent
+  from openai import AsyncOpenAI
+
+  # Load environment variables
+  load_dotenv()
+
+  # Initialize clients
+  agentmail = AsyncAgentMail(api_key=os.getenv("AGENTMAIL_API_KEY"))
+  openai = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+  # Simple conversation history (thread_id -> messages)
+  conversations = {}
+
+  # Store manager email for notifications
+  manager_email = None
+
+
+  def extract_email(from_field):
+      """Extract email address from 'Name <email@example.com>' format"""
+      match = re.search(r'<(.+?)>', from_field)
+      return match.group(1) if match else from_field
+
+
+  def is_from_manager(email_body):
+      """Simple check if email is from sales manager (contains customer info)"""
+      keywords = ['customer', 'lead', 'contact', 'reach out', 'email']
+      return any(keyword in email_body.lower() for keyword in keywords)
+
+
+  def extract_customer_info(email_body):
+      """Extract customer email from manager's message"""
+      email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+      emails = re.findall(email_pattern, email_body)
+
+      # Return the first email found (should be the customer's email in the message body)
+      if emails:
+          return emails[0]
+      return None
+
+
+  async def get_ai_response(messages, system_prompt):
+      """Get response from OpenAI"""
+      try:
+          response = await openai.chat.completions.create(
+              model="gpt-4o-mini",
+              messages=[
+                  {"role": "system", "content": system_prompt},
+                  *messages
+              ],
+              temperature=0.7,
+          )
+          return response.choices[0].message.content
+      except Exception as e:
+          print(f"Error getting AI response: {e}")
+          return "I apologize, but I encountered an error. Please try again."
+
+
+  async def send_email(inbox_id, to_email, subject, body):
+      """Send a new email"""
+      try:
+          await agentmail.inboxes.messages.send(
+              inbox_id=inbox_id,
+              to=[to_email],
+              subject=subject,
+              text=body
+          )
+          print(f"✓ Sent email to {to_email}")
+      except Exception as e:
+          print(f"Error sending email: {e}")
+
+
+  async def reply_to_email(inbox_id, message_id, to_email, body):
+      """Reply to an email"""
+      try:
+          await agentmail.inboxes.messages.reply(
+              inbox_id=inbox_id,
+              message_id=message_id,
+              to=[to_email],  # Required parameter for replies
+              text=body
+          )
+          print(f"✓ Sent reply to {to_email}")
+      except Exception as e:
+          print(f"Error replying: {e}")
+
+
+  async def handle_manager_email(inbox_id, message_id, from_email, subject, body):
+      """Handle email from sales manager - extract customer and send sales pitch"""
+      global manager_email
+      manager_email = from_email  # Remember manager for future notifications
+
+      print(f"\n📧 Email from MANAGER: {from_email}")
+
+      # Extract customer email
+      customer_email = extract_customer_info(body)
+      print(f"→ Extracted customer email: {customer_email}")
+
+      if not customer_email:
+          await reply_to_email(
+              inbox_id,
+              message_id,
+              from_email,  # Reply back to the manager
+              "I couldn't find a customer email address. Please include it in your message."
+          )
+          return
+
+      # Generate sales pitch using AI
+      system_prompt = """You are a helpful sales agent. Generate a brief, professional sales email
+      based on the manager's request. Keep it under 150 words. Be friendly and professional."""
+
+      messages = [{"role": "user", "content": f"Create a sales email based on this: {body}"}]
+      sales_pitch = await get_ai_response(messages, system_prompt)
+
+      # Send email to customer
+      await send_email(
+          inbox_id,
+          customer_email,
+          f"Introduction: {subject}" if subject else "Quick Introduction",
+          sales_pitch
+      )
+
+      # Confirm to manager
+      await reply_to_email(
+          inbox_id,
+          message_id,
+          from_email,  # Reply back to the manager
+          f"✓ I've sent an introduction email to {customer_email}.\n\nHere's what I sent:\n\n{sales_pitch}"
+      )
+
+
+  async def handle_customer_email(inbox_id, message_id, thread_id, from_email, subject, body):
+      """Handle email from customer - track conversation, detect intent, and notify manager"""
+      print(f"\n📧 Email from CUSTOMER: {from_email}")
+
+      # Track conversation history
+      if thread_id not in conversations:
+          conversations[thread_id] = []
+      conversations[thread_id].append({"role": "user", "content": body})
+
+      # Detect customer intent
+      intent_keywords = {
+          'interested': ['interested', 'demo', 'meeting', 'tell me more', 'sounds good'],
+          'not_interested': ['not interested', 'no thank', 'not right now', 'maybe later'],
+          'question': ['?', 'how', 'what', 'when', 'why', 'can you']
+      }
+
+      body_lower = body.lower()
+      intent = 'question'  # default
+      for key, keywords in intent_keywords.items():
+          if any(keyword in body_lower for keyword in keywords):
+              intent = key
+              break
+
+      # Generate AI response
+      system_prompt = """You are a helpful sales agent. Answer customer questions professionally
+      and helpfully. Keep responses brief (under 100 words). Be friendly but professional."""
+
+      response = await get_ai_response(conversations[thread_id], system_prompt)
+
+      # Reply to customer
+      await reply_to_email(inbox_id, message_id, from_email, response)
+
+      # Notify manager if strong intent signal
+      if manager_email and intent in ['interested', 'not_interested']:
+          status = "showing interest" if intent == 'interested' else "not interested at this time"
+          await send_email(
+              inbox_id,
+              manager_email,
+              f"Update: {from_email}",
+              f"Customer {from_email} is {status}.\n\nTheir message:\n{body}\n\nMy response:\n{response}"
+          )
+          print(f"→ Notified manager about customer's {intent}")
+
+      # Update conversation history
+      conversations[thread_id].append({"role": "assistant", "content": response})
+
+
+  async def handle_new_email(message):
+      """Process incoming email from WebSocket"""
+      try:
+          # Extract message data using object attributes
+          inbox_id = message.inbox_id
+          message_id = message.message_id
+          thread_id = message.thread_id
+          from_field = message.from_ or ""  # SDK uses from_
+          from_email = extract_email(from_field)
+          subject = message.subject or ""
+          body = message.text or ""  # SDK uses text for the body
+
+          print(f"\n{'='*60}")
+          print(f"New email from: {from_email}")
+          print(f"Subject: {subject}")
+          print(f"{'='*60}")
+
+          # Determine if from manager or customer
+          if is_from_manager(body):
+              await handle_manager_email(inbox_id, message_id, from_email, subject, body)
+          else:
+              await handle_customer_email(inbox_id, message_id, thread_id, from_email, subject, body)
+
+      except Exception as e:
+          print(f"Error handling email: {e}")
+
+
+  async def main():
+      """Main WebSocket loop"""
+      inbox_username = os.getenv("INBOX_USERNAME", "sales-agent")
+      inbox_id = f"{inbox_username}@agentmail.to"
+
+      print(f"\nSales Agent starting...")
+      print(f"Inbox: {inbox_id}")
+      print(f"✓ Connecting to AgentMail WebSocket...")
+
+      # Connect to WebSocket
+      try:
+          async with agentmail.websockets.connect() as socket:
+              print(f"✓ Connected! Listening for emails...\n")
+
+              # Subscribe to inbox
+              await socket.send_subscribe(Subscribe(inbox_ids=[inbox_id]))
+
+              # Listen for events
+              async for event in socket:
+                  if isinstance(event, Subscribed):
+                      print(f"✓ Subscribed to: {event.inbox_ids}\n")
+
+                  elif isinstance(event, MessageReceivedEvent):
+                      print(f"📨 New email received!")
+                      await handle_new_email(event.message)
+
+      except (KeyboardInterrupt, asyncio.CancelledError):
+          print("\n\nShutting down gracefully...")
+      except Exception as e:
+          print(f"\nError: {e}")
+
+
+  def run():
+      """Run the main function"""
+      try:
+          asyncio.run(main())
+      except KeyboardInterrupt:
+          print("\n✓ Shutdown complete")
+
+
+  if __name__ == "__main__":
+      run()
+  ```
+</Accordion>
+
+### Step 3: Create Requirements File
+
+Create a file named `requirements.txt`:
+
+```txt
+agentmail>=0.0.19
+openai>=1.0.0
+python-dotenv>=1.0.0
+```
+
+### Step 4: Install Dependencies
+
+Install the required Python packages:
+
+```bash
+pip install -r requirements.txt
+# or with pyproject.toml
+pip install .
+```
+
+### Step 5: Configure Environment Variables
+
+Create a `.env` file with your credentials:
+
+```env
+# AgentMail Configuration
+AGENTMAIL_API_KEY=your_agentmail_api_key_here
+
+# OpenAI Configuration
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Inbox Settings
+INBOX_USERNAME=sales-agent
+```
+
+<Callout intent="info">
+  **Note:** Unlike webhook-based agents, you don't need ngrok or a public URL. The WebSocket connection is outbound only, so it works behind firewalls without any port forwarding.
+</Callout>
+
+## Code Walkthrough
+
+Let's understand how the agent works by breaking down the key components.
+
+### Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      Your Python Script                      │
+│                                                              │
+│  ┌──────────────┐     ┌──────────────┐     ┌─────────────┐  │
+│  │ AsyncAgent   │────▶│ WebSocket    │────▶│ Event       │  │
+│  │ Mail Client  │     │ Connection   │     │ Handler     │  │
+│  └──────────────┘     └──────────────┘     └─────────────┘  │
+│         │                    ▲                    │          │
+│         │                    │                    ▼          │
+│         │              Real-time            ┌─────────────┐  │
+│         │              Events               │ OpenAI      │  │
+│         │                                   │ Integration │  │
+│         ▼                                   └─────────────┘  │
+│  ┌──────────────┐                                           │
+│  │ Send/Reply   │◀──────────────────────────────────────────│
+│  │ Emails       │                                           │
+│  └──────────────┘                                           │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+                    ┌──────────────────┐
+                    │   AgentMail      │
+                    │   Cloud          │
+                    └──────────────────┘
+```
+
+### 1. WebSocket Connection Setup
+
+The core of this agent is the WebSocket connection:
+
+```python
+from agentmail import AsyncAgentMail, Subscribe, Subscribed, MessageReceivedEvent
+
+# Initialize the async client
+agentmail = AsyncAgentMail(api_key=os.getenv("AGENTMAIL_API_KEY"))
+
+# Connect and subscribe
+async with agentmail.websockets.connect() as socket:
+    await socket.send_subscribe(Subscribe(inbox_ids=[inbox_id]))
+```
+
+**Key points:**
+
+* `AsyncAgentMail` is the async version of the client
+* `agentmail.websockets.connect()` creates the WebSocket connection
+* `Subscribe` specifies which inboxes to monitor
+
+### 2. Event Handling Loop
+
+The agent uses an async iterator pattern to process events:
+
+```python
+async for event in socket:
+    if isinstance(event, Subscribed):
+        print(f"✓ Subscribed to: {event.inbox_ids}")
+
+    elif isinstance(event, MessageReceivedEvent):
+        await handle_new_email(event.message)
+```
+
+**Event types:**
+
+* `Subscribed` - Confirmation that subscription was successful
+* `MessageReceivedEvent` - A new email arrived in the inbox
+
+### 3. Email Processing Flow
+
+The agent routes emails based on content:
+
+```python
+async def handle_new_email(message):
+    # Extract fields from the message object
+    inbox_id = message.inbox_id
+    message_id = message.message_id
+    thread_id = message.thread_id
+    from_field = message.from_ or ""  # Note: SDK uses from_
+    from_email = extract_email(from_field)
+    subject = message.subject or ""
+    body = message.text or ""
+
+    # Route based on email content
+    if is_from_manager(body):
+        await handle_manager_email(inbox_id, message_id, from_email, subject, body)
+    else:
+        await handle_customer_email(inbox_id, message_id, thread_id, from_email, subject, body)
+```
+
+**Email extraction helper:**
+
+```python
+def extract_email(from_field):
+    """Extract email from 'Name <email@example.com>' format"""
+    match = re.search(r'<(.+?)>', from_field)
+    return match.group(1) if match else from_field
+```
+
+### 4. Manager Email Handler
+
+When the manager sends an email with customer info:
+
+```python
+async def handle_manager_email(inbox_id, message_id, from_email, subject, body):
+    global manager_email
+    manager_email = from_email  # Remember for notifications
+
+    # Extract customer email using regex
+    customer_email = extract_customer_info(body)
+
+    if not customer_email:
+        await reply_to_email(inbox_id, message_id, from_email,
+            "I couldn't find a customer email. Please include it.")
+        return
+
+    # Generate AI sales pitch
+    sales_pitch = await get_ai_response(
+        [{"role": "user", "content": f"Create a sales email based on: {body}"}],
+        "You are a helpful sales agent. Generate a brief, professional email..."
+    )
+
+    # Send to customer
+    await send_email(inbox_id, customer_email, f"Introduction: {subject}", sales_pitch)
+
+    # Confirm to manager
+    await reply_to_email(inbox_id, message_id, from_email,
+        f"✓ Sent email to {customer_email}.\n\nContent:\n{sales_pitch}")
+```
+
+### 5. Customer Email Handler with Intent Detection
+
+The agent tracks conversations and detects customer intent:
+
+```python
+async def handle_customer_email(inbox_id, message_id, thread_id, from_email, subject, body):
+    # Track conversation history per thread
+    if thread_id not in conversations:
+        conversations[thread_id] = []
+    conversations[thread_id].append({"role": "user", "content": body})
+
+    # Detect intent with keyword matching
+    intent_keywords = {
+        'interested': ['interested', 'demo', 'meeting', 'tell me more'],
+        'not_interested': ['not interested', 'no thank', 'maybe later'],
+        'question': ['?', 'how', 'what', 'when', 'why']
+    }
+
+    intent = 'question'  # default
+    for key, keywords in intent_keywords.items():
+        if any(kw in body.lower() for kw in keywords):
+            intent = key
+            break
+
+    # Generate contextual AI response using conversation history
+    response = await get_ai_response(conversations[thread_id], system_prompt)
+
+    # Reply to customer
+    await reply_to_email(inbox_id, message_id, from_email, response)
+
+    # Notify manager of strong signals
+    if manager_email and intent in ['interested', 'not_interested']:
+        await send_email(inbox_id, manager_email, f"Update: {from_email}",
+            f"Customer is {intent}.\n\nTheir message:\n{body}")
+```
+
+### 6. AI Response Generation
+
+The agent uses OpenAI for generating responses:
+
+```python
+async def get_ai_response(messages, system_prompt):
+    try:
+        response = await openai.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                *messages  # Include conversation history
+            ],
+            temperature=0.7,
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        print(f"Error: {e}")
+        return "I apologize, but I encountered an error."
+```
+
+**Key points:**
+
+* Includes full conversation history for context
+* Graceful error handling with fallback message
+
+## Running the Agent
+
+Start the agent:
+
+```bash
+python main.py
+```
+
+You should see output like this:
+
+```
+Sales Agent starting...
+Inbox: sales-agent@agentmail.to
+✓ Connecting to AgentMail WebSocket...
+✓ Connected! Listening for emails...
+
+✓ Subscribed to: ['sales-agent@agentmail.to']
+```
+
+<Callout intent="success">
+  **Success!** Your agent is now running and listening for emails in real-time.
+
+  Leave this terminal window open - closing it will stop the agent.
+</Callout>
+
+## Testing Your Agent
+
+Let's verify everything works with some test scenarios.
+
+### Test Scenario: Manager Outreach Request
+
+**Send this email from your personal email:**
+
+```
+To: sales-agent@agentmail.to
+Subject: New lead - AI startup
+Body: Please reach out to this customer: customer-email@gmail.com
+      They're interested in our API platform.
+```
+
+**Expected console output:**
+
+```
+============================================================
+New email from: your-email@gmail.com
+Subject: New lead - AI startup
+============================================================
+
+📧 Email from MANAGER: your-email@gmail.com
+→ Extracted customer email: customer-email@gmail.com
+✓ Sent email to customer-email@gmail.com
+✓ Sent reply to your-email@gmail.com
+```
+
+**You'll receive:** A confirmation email with the sales pitch that was sent.
+
+<Callout intent="success">
+  **It works!** The agent processed emails in real-time, generated AI responses, and notified you about the interested customer.
+</Callout>
+
+## Customization
+
+### Modifying Intent Detection
+
+Update the `intent_keywords` dictionary in `handle_customer_email()`:
+
+```python
+intent_keywords = {
+    'interested': ['interested', 'demo', 'meeting', 'pricing', 'sign up'],
+    'not_interested': ['not interested', 'unsubscribe', 'remove me'],
+    'question': ['?', 'how', 'what', 'when', 'can you'],
+    'urgent': ['urgent', 'asap', 'immediately']  # Add new intent
+}
+```
+
+### Adding More Inbox Subscriptions
+
+Subscribe to multiple inboxes:
+
+```python
+await socket.send_subscribe(Subscribe(inbox_ids=[
+    "sales-agent@agentmail.to",
+    "support-agent@agentmail.to",
+    "info@yourdomain.com"
+]))
+```
+
+## Troubleshooting
+
+### Common Issues
+
+<Accordion title="WebSocket connection refused or timeout">
+  **Problem:** Cannot connect to AgentMail WebSocket.
+
+  **Solutions:**
+
+  1. Verify your API key is correct:
+
+  ```python
+  client = AsyncAgentMail(api_key="your-key")
+  print(await client.inboxes.list())  # Should succeed
+  ```
+
+  2. Check your internet connection and firewall settings
+  3. Ensure you're using `agentmail>=0.0.19` which includes WebSocket support:
+
+  ```bash
+  pip show agentmail
+  ```
+</Accordion>
+
+<Accordion title="Emails not being received">
+  **Problem:** Agent is running but not receiving emails.
+
+  **Checklist:**
+
+  1. Verify the inbox exists:
+
+  ```python
+  client = AsyncAgentMail()
+  print(await client.inboxes.get("sales-agent@agentmail.to"))
+  ```
+
+  2. Check subscription confirmation in console output
+  3. Send test email to the correct inbox address
+  4. Verify the email isn't being filtered as spam
+</Accordion>
 
-**Scenario**: Track email metrics and trends.
+<Accordion title="Agent crashes with asyncio errors">
+  **Problem:** Async-related exceptions.
 
-Build a dashboard that queries emails by labels to analyze:
+  **Solutions:**
 
-* **Sentiment trends**: Are customers getting happier or more frustrated?
-* **Volume by department**: Which team is handling the most emails?
-* **Response times by priority**: Are you meeting SLAs for urgent issues?
-* **Common categories**: What are customers asking about most?
+  1. Ensure Python 3.11+ is installed:
 
-Use this data to identify bottlenecks, improve processes, and make data-driven decisions about staffing and product priorities.
+  ```bash
+  python --version
+  ```
+
+  2. Don't mix sync and async code improperly
+  3. Use `asyncio.run(main())` as the entry point
+</Accordion>
 
 ***
 
-Congratulations! You've built an AI-powered email classification system. This agent showcases how AgentMail's labeling feature can power sophisticated inbox automation and analytics.
+If you build something cool with AgentMail, we'd love to hear about it. Share in our [Discord community](https://discord.gg/hTYatWYWBc)!
 
 
 # Live AgentMail Examples
@@ -6662,6 +7987,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -6670,9 +7996,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/inboxes"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -6696,6 +8025,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -6704,6 +8035,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -6713,8 +8046,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/inboxes', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -6725,19 +8060,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/inboxes");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -6868,6 +8212,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -6876,9 +8221,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/inboxes/inbox_id"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -6902,6 +8250,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -6910,6 +8260,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes/inbox_id")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -6919,8 +8271,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/inboxes/inbox_id', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -6931,19 +8285,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/inboxes/inbox_id");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes/inbox_id")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -7065,7 +8428,10 @@ async function main() {
         environment: "https://api.agentmail.to",
         apiKey: "YOUR_TOKEN_HERE",
     });
-    await client.inboxes.create();
+    await client.inboxes.create({
+        displayName: "Support Team Inbox",
+        clientId: "client-abcde",
+    });
 }
 main();
 
@@ -7079,7 +8445,10 @@ client = AgentMail(
     api_key="YOUR_TOKEN_HERE"
 )
 
-client.inboxes.create()
+client.inboxes.create(
+    display_name="Support Team Inbox",
+    client_id="client-abcde"
+)
 
 ```
 
@@ -7088,6 +8457,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -7096,7 +8466,9 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/inboxes"
 
-	req, _ := http.NewRequest("POST", url, nil)
+	payload := strings.NewReader("{\n  \"display_name\": \"Support Team Inbox\",\n  \"client_id\": \"client-abcde\",\n  \"pod_id\": \"pod-12345\",\n  \"inbox_id\": \"inbox-67890\"\n}")
+
+	req, _ := http.NewRequest("POST", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
 	req.Header.Add("Content-Type", "application/json")
@@ -7124,6 +8496,7 @@ http.use_ssl = true
 request = Net::HTTP::Post.new(url)
 request["Authorization"] = 'Bearer <api_key>'
 request["Content-Type"] = 'application/json'
+request.body = "{\n  \"display_name\": \"Support Team Inbox\",\n  \"client_id\": \"client-abcde\",\n  \"pod_id\": \"pod-12345\",\n  \"inbox_id\": \"inbox-67890\"\n}"
 
 response = http.request(request)
 puts response.read_body
@@ -7133,6 +8506,7 @@ puts response.read_body
 HttpResponse<String> response = Unirest.post("https://api.agentmail.to/v0/inboxes")
   .header("Authorization", "Bearer <api_key>")
   .header("Content-Type", "application/json")
+  .body("{\n  \"display_name\": \"Support Team Inbox\",\n  \"client_id\": \"client-abcde\",\n  \"pod_id\": \"pod-12345\",\n  \"inbox_id\": \"inbox-67890\"\n}")
   .asString();
 ```
 
@@ -7142,6 +8516,12 @@ HttpResponse<String> response = Unirest.post("https://api.agentmail.to/v0/inboxe
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('POST', 'https://api.agentmail.to/v0/inboxes', [
+  'body' => '{
+  "display_name": "Support Team Inbox",
+  "client_id": "client-abcde",
+  "pod_id": "pod-12345",
+  "inbox_id": "inbox-67890"
+}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
     'Content-Type' => 'application/json',
@@ -7156,6 +8536,7 @@ var client = new RestClient("https://api.agentmail.to/v0/inboxes");
 var request = new RestRequest(Method.POST);
 request.AddHeader("Authorization", "Bearer <api_key>");
 request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{\n  \"display_name\": \"Support Team Inbox\",\n  \"client_id\": \"client-abcde\",\n  \"pod_id\": \"pod-12345\",\n  \"inbox_id\": \"inbox-67890\"\n}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
@@ -7166,12 +8547,21 @@ let headers = [
   "Authorization": "Bearer <api_key>",
   "Content-Type": "application/json"
 ]
+let parameters = [
+  "display_name": "Support Team Inbox",
+  "client_id": "client-abcde",
+  "pod_id": "pod-12345",
+  "inbox_id": "inbox-67890"
+] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "POST"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -7765,7 +9155,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_threads:ThreadAttachments:
       type: array
       items:
@@ -7886,6 +9275,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -7894,9 +9284,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/inboxes/inbox_id/threads"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -7920,6 +9313,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -7928,6 +9323,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes/inbox_id/threads")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -7937,8 +9334,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/inboxes/inbox_id/threads', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -7949,19 +9348,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/inboxes/inbox_id/threads");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes/inbox_id/threads")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -8090,7 +9498,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_threads:ThreadAttachments:
       type: array
       items:
@@ -8460,10 +9867,9 @@ paths:
         '200':
           description: Response with status 200
           content:
-            application/octet-stream:
+            application/json:
               schema:
-                type: string
-                format: binary
+                $ref: '#/components/schemas/type_attachments:AttachmentResponse'
         '404':
           description: Error response with status 404
           content: {}
@@ -8475,6 +9881,46 @@ components:
       type: string
     type_attachments:AttachmentId:
       type: string
+    type_attachments:AttachmentFilename:
+      type: string
+    type_attachments:AttachmentSize:
+      type: integer
+    type_attachments:AttachmentContentType:
+      type: string
+    type_attachments:AttachmentContentDisposition:
+      type: string
+      enum:
+        - value: inline
+        - value: attachment
+    type_attachments:AttachmentContentId:
+      type: string
+    type_attachments:AttachmentResponse:
+      type: object
+      properties:
+        attachment_id:
+          $ref: '#/components/schemas/type_attachments:AttachmentId'
+        filename:
+          $ref: '#/components/schemas/type_attachments:AttachmentFilename'
+        size:
+          $ref: '#/components/schemas/type_attachments:AttachmentSize'
+        content_type:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentType'
+        content_disposition:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentDisposition'
+        content_id:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentId'
+        download_url:
+          type: string
+          description: URL to download the attachment.
+        expires_at:
+          type: string
+          format: date-time
+          description: Time at which the download URL expires.
+      required:
+        - attachment_id
+        - size
+        - download_url
+        - expires_at
 
 ```
 
@@ -8488,7 +9934,7 @@ async function main() {
         environment: "https://api.agentmail.to",
         apiKey: "YOUR_TOKEN_HERE",
     });
-    await client.inboxes.threads.getAttachment(":inbox_id", ":thread_id", ":attachment_id");
+    await client.inboxes.threads.getAttachment("inbox_id", "thread_id", "attachment_id");
 }
 main();
 
@@ -8503,9 +9949,9 @@ client = AgentMail(
 )
 
 client.inboxes.threads.get_attachment(
-    inbox_id=":inbox_id",
-    thread_id=":thread_id",
-    attachment_id=":attachment_id"
+    inbox_id="inbox_id",
+    thread_id="thread_id",
+    attachment_id="attachment_id"
 )
 
 ```
@@ -8521,7 +9967,7 @@ import (
 
 func main() {
 
-	url := "https://api.agentmail.to/v0/inboxes/%3Ainbox_id/threads/%3Athread_id/attachments/%3Aattachment_id"
+	url := "https://api.agentmail.to/v0/inboxes/inbox_id/threads/thread_id/attachments/attachment_id"
 
 	req, _ := http.NewRequest("GET", url, nil)
 
@@ -8542,7 +9988,7 @@ func main() {
 require 'uri'
 require 'net/http'
 
-url = URI("https://api.agentmail.to/v0/inboxes/%3Ainbox_id/threads/%3Athread_id/attachments/%3Aattachment_id")
+url = URI("https://api.agentmail.to/v0/inboxes/inbox_id/threads/thread_id/attachments/attachment_id")
 
 http = Net::HTTP.new(url.host, url.port)
 http.use_ssl = true
@@ -8555,7 +10001,7 @@ puts response.read_body
 ```
 
 ```java
-HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes/%3Ainbox_id/threads/%3Athread_id/attachments/%3Aattachment_id")
+HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes/inbox_id/threads/thread_id/attachments/attachment_id")
   .header("Authorization", "Bearer <api_key>")
   .asString();
 ```
@@ -8565,7 +10011,7 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes
 
 $client = new \GuzzleHttp\Client();
 
-$response = $client->request('GET', 'https://api.agentmail.to/v0/inboxes/%3Ainbox_id/threads/%3Athread_id/attachments/%3Aattachment_id', [
+$response = $client->request('GET', 'https://api.agentmail.to/v0/inboxes/inbox_id/threads/thread_id/attachments/attachment_id', [
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
   ],
@@ -8575,7 +10021,7 @@ echo $response->getBody();
 ```
 
 ```csharp
-var client = new RestClient("https://api.agentmail.to/v0/inboxes/%3Ainbox_id/threads/%3Athread_id/attachments/%3Aattachment_id");
+var client = new RestClient("https://api.agentmail.to/v0/inboxes/inbox_id/threads/thread_id/attachments/attachment_id");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
 IRestResponse response = client.Execute(request);
@@ -8586,7 +10032,7 @@ import Foundation
 
 let headers = ["Authorization": "Bearer <api_key>"]
 
-let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes/%3Ainbox_id/threads/%3Athread_id/attachments/%3Aattachment_id")! as URL,
+let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes/inbox_id/threads/thread_id/attachments/attachment_id")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
@@ -8952,7 +10398,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_messages:MessageAttachments:
       type: array
       items:
@@ -9290,7 +10735,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_messages:MessageAttachments:
       type: array
       items:
@@ -9558,10 +11002,9 @@ paths:
         '200':
           description: Response with status 200
           content:
-            application/octet-stream:
+            application/json:
               schema:
-                type: string
-                format: binary
+                $ref: '#/components/schemas/type_attachments:AttachmentResponse'
         '404':
           description: Error response with status 404
           content: {}
@@ -9573,6 +11016,46 @@ components:
       type: string
     type_attachments:AttachmentId:
       type: string
+    type_attachments:AttachmentFilename:
+      type: string
+    type_attachments:AttachmentSize:
+      type: integer
+    type_attachments:AttachmentContentType:
+      type: string
+    type_attachments:AttachmentContentDisposition:
+      type: string
+      enum:
+        - value: inline
+        - value: attachment
+    type_attachments:AttachmentContentId:
+      type: string
+    type_attachments:AttachmentResponse:
+      type: object
+      properties:
+        attachment_id:
+          $ref: '#/components/schemas/type_attachments:AttachmentId'
+        filename:
+          $ref: '#/components/schemas/type_attachments:AttachmentFilename'
+        size:
+          $ref: '#/components/schemas/type_attachments:AttachmentSize'
+        content_type:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentType'
+        content_disposition:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentDisposition'
+        content_id:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentId'
+        download_url:
+          type: string
+          description: URL to download the attachment.
+        expires_at:
+          type: string
+          format: date-time
+          description: Time at which the download URL expires.
+      required:
+        - attachment_id
+        - size
+        - download_url
+        - expires_at
 
 ```
 
@@ -9586,7 +11069,7 @@ async function main() {
         environment: "https://api.agentmail.to",
         apiKey: "YOUR_TOKEN_HERE",
     });
-    await client.inboxes.messages.getAttachment(":inbox_id", ":message_id", ":attachment_id");
+    await client.inboxes.messages.getAttachment("inbox_id", "message_id", "attachment_id");
 }
 main();
 
@@ -9601,9 +11084,9 @@ client = AgentMail(
 )
 
 client.inboxes.messages.get_attachment(
-    inbox_id=":inbox_id",
-    message_id=":message_id",
-    attachment_id=":attachment_id"
+    inbox_id="inbox_id",
+    message_id="message_id",
+    attachment_id="attachment_id"
 )
 
 ```
@@ -9619,7 +11102,7 @@ import (
 
 func main() {
 
-	url := "https://api.agentmail.to/v0/inboxes/%3Ainbox_id/messages/%3Amessage_id/attachments/%3Aattachment_id"
+	url := "https://api.agentmail.to/v0/inboxes/inbox_id/messages/message_id/attachments/attachment_id"
 
 	req, _ := http.NewRequest("GET", url, nil)
 
@@ -9640,7 +11123,7 @@ func main() {
 require 'uri'
 require 'net/http'
 
-url = URI("https://api.agentmail.to/v0/inboxes/%3Ainbox_id/messages/%3Amessage_id/attachments/%3Aattachment_id")
+url = URI("https://api.agentmail.to/v0/inboxes/inbox_id/messages/message_id/attachments/attachment_id")
 
 http = Net::HTTP.new(url.host, url.port)
 http.use_ssl = true
@@ -9653,7 +11136,7 @@ puts response.read_body
 ```
 
 ```java
-HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes/%3Ainbox_id/messages/%3Amessage_id/attachments/%3Aattachment_id")
+HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes/inbox_id/messages/message_id/attachments/attachment_id")
   .header("Authorization", "Bearer <api_key>")
   .asString();
 ```
@@ -9663,7 +11146,7 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes
 
 $client = new \GuzzleHttp\Client();
 
-$response = $client->request('GET', 'https://api.agentmail.to/v0/inboxes/%3Ainbox_id/messages/%3Amessage_id/attachments/%3Aattachment_id', [
+$response = $client->request('GET', 'https://api.agentmail.to/v0/inboxes/inbox_id/messages/message_id/attachments/attachment_id', [
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
   ],
@@ -9673,7 +11156,7 @@ echo $response->getBody();
 ```
 
 ```csharp
-var client = new RestClient("https://api.agentmail.to/v0/inboxes/%3Ainbox_id/messages/%3Amessage_id/attachments/%3Aattachment_id");
+var client = new RestClient("https://api.agentmail.to/v0/inboxes/inbox_id/messages/message_id/attachments/attachment_id");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
 IRestResponse response = client.Execute(request);
@@ -9684,7 +11167,7 @@ import Foundation
 
 let headers = ["Authorization": "Bearer <api_key>"]
 
-let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes/%3Ainbox_id/messages/%3Amessage_id/attachments/%3Aattachment_id")! as URL,
+let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes/inbox_id/messages/message_id/attachments/attachment_id")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
@@ -10942,7 +12425,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_messages:MessageAttachments:
       type: array
       items:
@@ -11334,7 +12816,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_drafts:DraftAttachments:
       type: array
       items:
@@ -11652,7 +13133,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_drafts:DraftAttachments:
       type: array
       items:
@@ -12007,7 +13487,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_drafts:DraftAttachments:
       type: array
       items:
@@ -12372,7 +13851,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_drafts:DraftAttachments:
       type: array
       items:
@@ -13193,6 +14671,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -13201,9 +14680,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/inboxes/inbox_id/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -13227,6 +14709,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -13235,6 +14719,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes/inbox_id/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -13244,8 +14730,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/inboxes
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/inboxes/inbox_id/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -13256,19 +14744,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/inboxes/inbox_id/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/inboxes/inbox_id/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -13441,7 +14938,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_threads:ThreadAttachments:
       type: array
       items:
@@ -13560,6 +15056,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -13568,9 +15065,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/threads"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -13594,6 +15094,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -13602,6 +15104,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/threads")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -13611,8 +15115,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/threads
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/threads', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -13623,19 +15129,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/threads");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/threads")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -13758,7 +15273,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_threads:ThreadAttachments:
       type: array
       items:
@@ -14121,10 +15635,9 @@ paths:
         '200':
           description: Response with status 200
           content:
-            application/octet-stream:
+            application/json:
               schema:
-                type: string
-                format: binary
+                $ref: '#/components/schemas/type_attachments:AttachmentResponse'
         '404':
           description: Error response with status 404
           content: {}
@@ -14134,6 +15647,46 @@ components:
       type: string
     type_attachments:AttachmentId:
       type: string
+    type_attachments:AttachmentFilename:
+      type: string
+    type_attachments:AttachmentSize:
+      type: integer
+    type_attachments:AttachmentContentType:
+      type: string
+    type_attachments:AttachmentContentDisposition:
+      type: string
+      enum:
+        - value: inline
+        - value: attachment
+    type_attachments:AttachmentContentId:
+      type: string
+    type_attachments:AttachmentResponse:
+      type: object
+      properties:
+        attachment_id:
+          $ref: '#/components/schemas/type_attachments:AttachmentId'
+        filename:
+          $ref: '#/components/schemas/type_attachments:AttachmentFilename'
+        size:
+          $ref: '#/components/schemas/type_attachments:AttachmentSize'
+        content_type:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentType'
+        content_disposition:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentDisposition'
+        content_id:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentId'
+        download_url:
+          type: string
+          description: URL to download the attachment.
+        expires_at:
+          type: string
+          format: date-time
+          description: Time at which the download URL expires.
+      required:
+        - attachment_id
+        - size
+        - download_url
+        - expires_at
 
 ```
 
@@ -14147,7 +15700,7 @@ async function main() {
         environment: "https://api.agentmail.to",
         apiKey: "YOUR_TOKEN_HERE",
     });
-    await client.threads.getAttachment(":thread_id", ":attachment_id");
+    await client.threads.getAttachment("thread_id", "attachment_id");
 }
 main();
 
@@ -14162,8 +15715,8 @@ client = AgentMail(
 )
 
 client.threads.get_attachment(
-    thread_id=":thread_id",
-    attachment_id=":attachment_id"
+    thread_id="thread_id",
+    attachment_id="attachment_id"
 )
 
 ```
@@ -14179,7 +15732,7 @@ import (
 
 func main() {
 
-	url := "https://api.agentmail.to/v0/threads/%3Athread_id/attachments/%3Aattachment_id"
+	url := "https://api.agentmail.to/v0/threads/thread_id/attachments/attachment_id"
 
 	req, _ := http.NewRequest("GET", url, nil)
 
@@ -14200,7 +15753,7 @@ func main() {
 require 'uri'
 require 'net/http'
 
-url = URI("https://api.agentmail.to/v0/threads/%3Athread_id/attachments/%3Aattachment_id")
+url = URI("https://api.agentmail.to/v0/threads/thread_id/attachments/attachment_id")
 
 http = Net::HTTP.new(url.host, url.port)
 http.use_ssl = true
@@ -14213,7 +15766,7 @@ puts response.read_body
 ```
 
 ```java
-HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/threads/%3Athread_id/attachments/%3Aattachment_id")
+HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/threads/thread_id/attachments/attachment_id")
   .header("Authorization", "Bearer <api_key>")
   .asString();
 ```
@@ -14223,7 +15776,7 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/threads
 
 $client = new \GuzzleHttp\Client();
 
-$response = $client->request('GET', 'https://api.agentmail.to/v0/threads/%3Athread_id/attachments/%3Aattachment_id', [
+$response = $client->request('GET', 'https://api.agentmail.to/v0/threads/thread_id/attachments/attachment_id', [
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
   ],
@@ -14233,7 +15786,7 @@ echo $response->getBody();
 ```
 
 ```csharp
-var client = new RestClient("https://api.agentmail.to/v0/threads/%3Athread_id/attachments/%3Aattachment_id");
+var client = new RestClient("https://api.agentmail.to/v0/threads/thread_id/attachments/attachment_id");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
 IRestResponse response = client.Execute(request);
@@ -14244,7 +15797,7 @@ import Foundation
 
 let headers = ["Authorization": "Bearer <api_key>"]
 
-let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/threads/%3Athread_id/attachments/%3Aattachment_id")! as URL,
+let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/threads/thread_id/attachments/attachment_id")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
@@ -14411,7 +15964,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_drafts:DraftAttachments:
       type: array
       items:
@@ -14721,7 +16273,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_drafts:DraftAttachments:
       type: array
       items:
@@ -15062,6 +16613,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -15070,9 +16622,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/domains"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -15096,6 +16651,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -15104,6 +16661,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/domains")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -15113,8 +16672,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/domains
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/domains', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -15125,19 +16686,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/domains");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/domains")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -15748,7 +17318,7 @@ async function main() {
         apiKey: "YOUR_TOKEN_HERE",
     });
     await client.domains.create({
-        domain: "domain",
+        domain: "example.com",
         feedbackEnabled: true,
     });
 }
@@ -15765,7 +17335,7 @@ client = AgentMail(
 )
 
 client.domains.create(
-    domain="domain",
+    domain="example.com",
     feedback_enabled=True
 )
 
@@ -15785,7 +17355,7 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/domains"
 
-	payload := strings.NewReader("{\n  \"domain\": \"domain\",\n  \"feedback_enabled\": true\n}")
+	payload := strings.NewReader("{\n  \"domain\": \"example.com\",\n  \"feedback_enabled\": true\n}")
 
 	req, _ := http.NewRequest("POST", url, payload)
 
@@ -15815,7 +17385,7 @@ http.use_ssl = true
 request = Net::HTTP::Post.new(url)
 request["Authorization"] = 'Bearer <api_key>'
 request["Content-Type"] = 'application/json'
-request.body = "{\n  \"domain\": \"domain\",\n  \"feedback_enabled\": true\n}"
+request.body = "{\n  \"domain\": \"example.com\",\n  \"feedback_enabled\": true\n}"
 
 response = http.request(request)
 puts response.read_body
@@ -15825,7 +17395,7 @@ puts response.read_body
 HttpResponse<String> response = Unirest.post("https://api.agentmail.to/v0/domains")
   .header("Authorization", "Bearer <api_key>")
   .header("Content-Type", "application/json")
-  .body("{\n  \"domain\": \"domain\",\n  \"feedback_enabled\": true\n}")
+  .body("{\n  \"domain\": \"example.com\",\n  \"feedback_enabled\": true\n}")
   .asString();
 ```
 
@@ -15836,7 +17406,7 @@ $client = new \GuzzleHttp\Client();
 
 $response = $client->request('POST', 'https://api.agentmail.to/v0/domains', [
   'body' => '{
-  "domain": "domain",
+  "domain": "example.com",
   "feedback_enabled": true
 }',
   'headers' => [
@@ -15853,7 +17423,7 @@ var client = new RestClient("https://api.agentmail.to/v0/domains");
 var request = new RestRequest(Method.POST);
 request.AddHeader("Authorization", "Bearer <api_key>");
 request.AddHeader("Content-Type", "application/json");
-request.AddParameter("application/json", "{\n  \"domain\": \"domain\",\n  \"feedback_enabled\": true\n}", ParameterType.RequestBody);
+request.AddParameter("application/json", "{\n  \"domain\": \"example.com\",\n  \"feedback_enabled\": true\n}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
@@ -15865,7 +17435,7 @@ let headers = [
   "Content-Type": "application/json"
 ]
 let parameters = [
-  "domain": "domain",
+  "domain": "example.com",
   "feedback_enabled": true
 ] as [String : Any]
 
@@ -17322,7 +18892,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_messages:MessageAttachments:
       type: array
       items:
@@ -18478,7 +20047,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_messages:MessageAttachments:
       type: array
       items:
@@ -19225,6 +20793,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -19233,9 +20802,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -19259,6 +20831,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -19267,6 +20841,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -19276,8 +20852,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/metrics
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -19288,19 +20866,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/metrics?start_timestamp=2024-01-15T09%3A30%3A00Z&end_timestamp=2024-01-15T09%3A30%3A00Z")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -19449,6 +21036,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -19457,9 +21045,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/api-keys"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -19483,6 +21074,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -19491,6 +21084,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/api-keys")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -19500,8 +21095,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/api-key
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/api-keys', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -19512,19 +21109,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/api-keys");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/api-keys")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -20080,6 +21686,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -20088,9 +21695,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/pods"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -20114,6 +21724,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -20122,6 +21734,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -20131,8 +21745,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods")
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/pods', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -20143,19 +21759,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/pods");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/pods")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -20282,6 +21907,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -20290,9 +21916,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/pods/pod_id"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -20316,6 +21945,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -20324,6 +21955,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/pod_id")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -20333,8 +21966,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/po
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/pods/pod_id', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -20345,19 +21980,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/pods/pod_id");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/pods/pod_id")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -20921,6 +22565,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -20929,9 +22574,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/pods/pod_id/inboxes"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -20955,6 +22603,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -20963,6 +22613,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/pod_id/inboxes")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -20972,8 +22624,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/po
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/pods/pod_id/inboxes', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -20984,19 +22638,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/pods/pod_id/inboxes");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/pods/pod_id/inboxes")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -21134,6 +22797,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -21142,9 +22806,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/pods/pod_id/inboxes/inbox_id"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -21168,6 +22835,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -21176,6 +22845,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/pod_id/inboxes/inbox_id")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -21185,8 +22856,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/po
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/pods/pod_id/inboxes/inbox_id', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -21197,19 +22870,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/pods/pod_id/inboxes/inbox_id");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/pods/pod_id/inboxes/inbox_id")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -21818,7 +23500,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_threads:ThreadAttachments:
       type: array
       items:
@@ -21939,6 +23620,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -21947,9 +23629,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/pods/pod_id/threads"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -21973,6 +23658,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -21981,6 +23668,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/pod_id/threads")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -21990,8 +23679,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/po
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/pods/pod_id/threads', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -22002,19 +23693,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/pods/pod_id/threads");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/pods/pod_id/threads")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -22145,7 +23845,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_threads:ThreadAttachments:
       type: array
       items:
@@ -22515,10 +24214,9 @@ paths:
         '200':
           description: Response with status 200
           content:
-            application/octet-stream:
+            application/json:
               schema:
-                type: string
-                format: binary
+                $ref: '#/components/schemas/type_attachments:AttachmentResponse'
         '404':
           description: Error response with status 404
           content: {}
@@ -22530,6 +24228,46 @@ components:
       type: string
     type_attachments:AttachmentId:
       type: string
+    type_attachments:AttachmentFilename:
+      type: string
+    type_attachments:AttachmentSize:
+      type: integer
+    type_attachments:AttachmentContentType:
+      type: string
+    type_attachments:AttachmentContentDisposition:
+      type: string
+      enum:
+        - value: inline
+        - value: attachment
+    type_attachments:AttachmentContentId:
+      type: string
+    type_attachments:AttachmentResponse:
+      type: object
+      properties:
+        attachment_id:
+          $ref: '#/components/schemas/type_attachments:AttachmentId'
+        filename:
+          $ref: '#/components/schemas/type_attachments:AttachmentFilename'
+        size:
+          $ref: '#/components/schemas/type_attachments:AttachmentSize'
+        content_type:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentType'
+        content_disposition:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentDisposition'
+        content_id:
+          $ref: '#/components/schemas/type_attachments:AttachmentContentId'
+        download_url:
+          type: string
+          description: URL to download the attachment.
+        expires_at:
+          type: string
+          format: date-time
+          description: Time at which the download URL expires.
+      required:
+        - attachment_id
+        - size
+        - download_url
+        - expires_at
 
 ```
 
@@ -22543,7 +24281,7 @@ async function main() {
         environment: "https://api.agentmail.to",
         apiKey: "YOUR_TOKEN_HERE",
     });
-    await client.pods.threads.getAttachment(":pod_id", ":thread_id", ":attachment_id");
+    await client.pods.threads.getAttachment("pod_id", "thread_id", "attachment_id");
 }
 main();
 
@@ -22558,9 +24296,9 @@ client = AgentMail(
 )
 
 client.pods.threads.get_attachment(
-    pod_id=":pod_id",
-    thread_id=":thread_id",
-    attachment_id=":attachment_id"
+    pod_id="pod_id",
+    thread_id="thread_id",
+    attachment_id="attachment_id"
 )
 
 ```
@@ -22576,7 +24314,7 @@ import (
 
 func main() {
 
-	url := "https://api.agentmail.to/v0/pods/%3Apod_id/threads/%3Athread_id/attachments/%3Aattachment_id"
+	url := "https://api.agentmail.to/v0/pods/pod_id/threads/thread_id/attachments/attachment_id"
 
 	req, _ := http.NewRequest("GET", url, nil)
 
@@ -22597,7 +24335,7 @@ func main() {
 require 'uri'
 require 'net/http'
 
-url = URI("https://api.agentmail.to/v0/pods/%3Apod_id/threads/%3Athread_id/attachments/%3Aattachment_id")
+url = URI("https://api.agentmail.to/v0/pods/pod_id/threads/thread_id/attachments/attachment_id")
 
 http = Net::HTTP.new(url.host, url.port)
 http.use_ssl = true
@@ -22610,7 +24348,7 @@ puts response.read_body
 ```
 
 ```java
-HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/%3Apod_id/threads/%3Athread_id/attachments/%3Aattachment_id")
+HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/pod_id/threads/thread_id/attachments/attachment_id")
   .header("Authorization", "Bearer <api_key>")
   .asString();
 ```
@@ -22620,7 +24358,7 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/%3
 
 $client = new \GuzzleHttp\Client();
 
-$response = $client->request('GET', 'https://api.agentmail.to/v0/pods/%3Apod_id/threads/%3Athread_id/attachments/%3Aattachment_id', [
+$response = $client->request('GET', 'https://api.agentmail.to/v0/pods/pod_id/threads/thread_id/attachments/attachment_id', [
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
   ],
@@ -22630,7 +24368,7 @@ echo $response->getBody();
 ```
 
 ```csharp
-var client = new RestClient("https://api.agentmail.to/v0/pods/%3Apod_id/threads/%3Athread_id/attachments/%3Aattachment_id");
+var client = new RestClient("https://api.agentmail.to/v0/pods/pod_id/threads/thread_id/attachments/attachment_id");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
 IRestResponse response = client.Execute(request);
@@ -22641,7 +24379,7 @@ import Foundation
 
 let headers = ["Authorization": "Bearer <api_key>"]
 
-let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/pods/%3Apod_id/threads/%3Athread_id/attachments/%3Aattachment_id")! as URL,
+let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/pods/pod_id/threads/thread_id/attachments/attachment_id")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
@@ -22816,7 +24554,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_drafts:DraftAttachments:
       type: array
       items:
@@ -23136,7 +24873,6 @@ components:
       required:
         - attachment_id
         - size
-        - content_disposition
     type_drafts:DraftAttachments:
       type: array
       items:
@@ -23489,6 +25225,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -23497,9 +25234,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/pods/pod_id/domains"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -23523,6 +25263,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -23531,6 +25273,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/pod_id/domains")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -23540,8 +25284,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/pods/po
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/pods/pod_id/domains', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -23552,19 +25298,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/pods/pod_id/domains");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/pods/pod_id/domains")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
@@ -23744,7 +25499,7 @@ async function main() {
         apiKey: "YOUR_TOKEN_HERE",
     });
     await client.pods.domains.create("pod_id", {
-        domain: "domain",
+        domain: "example.com",
         feedbackEnabled: true,
     });
 }
@@ -23762,7 +25517,7 @@ client = AgentMail(
 
 client.pods.domains.create(
     pod_id="pod_id",
-    domain="domain",
+    domain="example.com",
     feedback_enabled=True
 )
 
@@ -23782,7 +25537,7 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/pods/pod_id/domains"
 
-	payload := strings.NewReader("{\n  \"domain\": \"domain\",\n  \"feedback_enabled\": true\n}")
+	payload := strings.NewReader("{\n  \"domain\": \"example.com\",\n  \"feedback_enabled\": true\n}")
 
 	req, _ := http.NewRequest("POST", url, payload)
 
@@ -23812,7 +25567,7 @@ http.use_ssl = true
 request = Net::HTTP::Post.new(url)
 request["Authorization"] = 'Bearer <api_key>'
 request["Content-Type"] = 'application/json'
-request.body = "{\n  \"domain\": \"domain\",\n  \"feedback_enabled\": true\n}"
+request.body = "{\n  \"domain\": \"example.com\",\n  \"feedback_enabled\": true\n}"
 
 response = http.request(request)
 puts response.read_body
@@ -23822,7 +25577,7 @@ puts response.read_body
 HttpResponse<String> response = Unirest.post("https://api.agentmail.to/v0/pods/pod_id/domains")
   .header("Authorization", "Bearer <api_key>")
   .header("Content-Type", "application/json")
-  .body("{\n  \"domain\": \"domain\",\n  \"feedback_enabled\": true\n}")
+  .body("{\n  \"domain\": \"example.com\",\n  \"feedback_enabled\": true\n}")
   .asString();
 ```
 
@@ -23833,7 +25588,7 @@ $client = new \GuzzleHttp\Client();
 
 $response = $client->request('POST', 'https://api.agentmail.to/v0/pods/pod_id/domains', [
   'body' => '{
-  "domain": "domain",
+  "domain": "example.com",
   "feedback_enabled": true
 }',
   'headers' => [
@@ -23850,7 +25605,7 @@ var client = new RestClient("https://api.agentmail.to/v0/pods/pod_id/domains");
 var request = new RestRequest(Method.POST);
 request.AddHeader("Authorization", "Bearer <api_key>");
 request.AddHeader("Content-Type", "application/json");
-request.AddParameter("application/json", "{\n  \"domain\": \"domain\",\n  \"feedback_enabled\": true\n}", ParameterType.RequestBody);
+request.AddParameter("application/json", "{\n  \"domain\": \"example.com\",\n  \"feedback_enabled\": true\n}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
@@ -23862,7 +25617,7 @@ let headers = [
   "Content-Type": "application/json"
 ]
 let parameters = [
-  "domain": "domain",
+  "domain": "example.com",
   "feedback_enabled": true
 ] as [String : Any]
 
@@ -24179,6 +25934,7 @@ package main
 
 import (
 	"fmt"
+	"strings"
 	"net/http"
 	"io"
 )
@@ -24187,9 +25943,12 @@ func main() {
 
 	url := "https://api.agentmail.to/v0/organizations"
 
-	req, _ := http.NewRequest("GET", url, nil)
+	payload := strings.NewReader("{}")
+
+	req, _ := http.NewRequest("GET", url, payload)
 
 	req.Header.Add("Authorization", "Bearer <api_key>")
+	req.Header.Add("Content-Type", "application/json")
 
 	res, _ := http.DefaultClient.Do(req)
 
@@ -24213,6 +25972,8 @@ http.use_ssl = true
 
 request = Net::HTTP::Get.new(url)
 request["Authorization"] = 'Bearer <api_key>'
+request["Content-Type"] = 'application/json'
+request.body = "{}"
 
 response = http.request(request)
 puts response.read_body
@@ -24221,6 +25982,8 @@ puts response.read_body
 ```java
 HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/organizations")
   .header("Authorization", "Bearer <api_key>")
+  .header("Content-Type", "application/json")
+  .body("{}")
   .asString();
 ```
 
@@ -24230,8 +25993,10 @@ HttpResponse<String> response = Unirest.get("https://api.agentmail.to/v0/organiz
 $client = new \GuzzleHttp\Client();
 
 $response = $client->request('GET', 'https://api.agentmail.to/v0/organizations', [
+  'body' => '{}',
   'headers' => [
     'Authorization' => 'Bearer <api_key>',
+    'Content-Type' => 'application/json',
   ],
 ]);
 
@@ -24242,19 +26007,28 @@ echo $response->getBody();
 var client = new RestClient("https://api.agentmail.to/v0/organizations");
 var request = new RestRequest(Method.GET);
 request.AddHeader("Authorization", "Bearer <api_key>");
+request.AddHeader("Content-Type", "application/json");
+request.AddParameter("application/json", "{}", ParameterType.RequestBody);
 IRestResponse response = client.Execute(request);
 ```
 
 ```swift
 import Foundation
 
-let headers = ["Authorization": "Bearer <api_key>"]
+let headers = [
+  "Authorization": "Bearer <api_key>",
+  "Content-Type": "application/json"
+]
+let parameters = [] as [String : Any]
+
+let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
 
 let request = NSMutableURLRequest(url: NSURL(string: "https://api.agentmail.to/v0/organizations")! as URL,
                                         cachePolicy: .useProtocolCachePolicy,
                                     timeoutInterval: 10.0)
 request.httpMethod = "GET"
 request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
 
 let session = URLSession.shared
 let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in