1. 1
   Navigate to Workspace Settings in the sidebar
2. 2
   Scroll to the Webhooks section
3. 3
   Click Add Destination
4. 4
   Enter your HTTPS webhook URL and an optional description
5. 5
   Add any custom headers your endpoint requires (e.g., API keys, authorization tokens)
6. 6
   Click Create Destination
7. 7
   Copy the HMAC secret — it is shown only once. Store it securely.
8. 8
   Click the Test button to send a test event and verify delivery

[
  {
    "specversion": "1.0",
    "id": "aud_abc123",
    "source": "https://app.atmos.pro/workspaces/ws_xyz",
    "type": "pro.atmos.workspace.created",
    "time": "2025-01-15T10:30:00.000Z",
    "subject": "ws_target1",
    "datacontenttype": "application/json",
    "data": {
      "actor": { "id": "usr_actor1", "type": "user" },
      "action": { "category": "workspace", "action": "created" },
      "target": { "type": "workspace", "id": "ws_target1" },
      "description": null,
      "metadata": {}
    }
  }
]

X-Webhook-Signature: sha256=5d7861...

const crypto = require('crypto');
 
function verifySignature(body, secret, signatureHeader) {
  const expected = 'sha256=' + crypto.createHmac('sha256', secret)
    .update(body)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signatureHeader),
    Buffer.from(expected)
  );
}
 
// In your webhook handler:
const body = req.body; // raw string, not parsed JSON
const signature = req.headers['x-webhook-signature'];
if (!verifySignature(body, process.env.WEBHOOK_SECRET, signature)) {
  return res.status(401).send('Invalid signature');
}

import hmac
import hashlib
 
def verify_signature(body: bytes, secret: str, signature_header: str) -> bool:
    expected = 'sha256=' + hmac.new(
        secret.encode(), body, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature_header, expected)

package main
 
import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)
 
func verifySignature(body []byte, secret string, signatureHeader string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(body)
    expected := "sha256=" + hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(signatureHeader), []byte(expected))
}

• Events are batched — up to 100 events are collected over a 30-second window before delivery
• Failed deliveries are retried up to 5 times with exponential backoff
• After all retries are exhausted, an alert email is sent to notify you of the failure
• Delivery status (success/failure) is visible in the webhook destinations list in workspace settings
• The X-Webhook-Id header identifies which destination received the delivery

1. 1
   Create an HTTP Source in your Sumo Logic collector
2. 2
   Copy the HTTP Source URL
3. 3
   Add it as a webhook destination in Atmos Pro
4. 4
   Events arrive as JSON arrays — use the json operator in Sumo Logic to parse them

1. 1
   Create an HTTP Event Collector (HEC) token in Splunk
2. 2
   Set the webhook URL to https://your-splunk:8088/services/collector/event
3. 3
   Add a custom header: Authorization: Splunk <your-hec-token>
4. 4
   Events will appear in the index associated with your HEC token

1. 1
   Use the Log Intake API endpoint
2. 2
   Set the webhook URL to https://http-intake.logs.datadoghq.com/api/v2/logs
3. 3
   Add a custom header: DD-API-KEY: <your-api-key>
4. 4
   Optionally add ddsource: atmos-pro and ddtags: env:production headers

• Verify the destination URL is reachable and returns a 2xx status code
• Check that HTTPS is used (HTTP URLs are not allowed)
• Verify any custom headers (e.g., API keys) are correct and not expired
• Check your endpoint's firewall or IP allowlist

• Confirm the destination is enabled in workspace settings
• Check the audit log viewer to verify events are being recorded
• Send a test event to confirm connectivity

• Verify against the raw request body (the exact bytes received), not a re-serialized version
• Use timing-safe comparison (e.g., crypto.timingSafeEqual in Node.js)
• Ensure you are using the correct secret for the destination