perplexity-webhooks-events
Implement Perplexity webhook signature validation and event handling.Use when setting up webhook endpoints, implementing signature verification,or handling Perplexity event notifications securely.Trigger with phrases like "perplexity webhook", "perplexity events","perplexity webhook signature", "handle perplexity events", "perplexity notifications".
When & Why to Use This Skill
This Claude skill facilitates the secure implementation of Perplexity webhooks, offering comprehensive tools for signature validation, replay protection, and structured event handling. It provides developers with production-ready boilerplate and logic to ensure that real-time data notifications from Perplexity are processed securely, reliably, and with protection against common web vulnerabilities like replay attacks.
Use Cases
- Secure Webhook Integration: Establish a hardened Express.js endpoint that validates 'x-perplexity-signature' headers using HMAC SHA256 to prevent unauthorized data injection.
- Real-time Data Synchronization: Automatically trigger internal workflows or update local databases whenever Perplexity resources are created, updated, or deleted.
- Production-Grade Reliability: Implement idempotency logic using Redis to ensure that webhook events are processed exactly once, even in the event of network retries.
- Security Compliance: Protect your infrastructure from replay attacks by implementing timestamp verification and timing-safe signature comparisons.
| name | perplexity-webhooks-events |
|---|---|
| description | | |
| allowed-tools | Read, Write, Edit, Bash(curl:*) |
| version | 1.0.0 |
| license | MIT |
| author | Jeremy Longshore <jeremy@intentsolutions.io> |
Perplexity Webhooks & Events
Overview
Securely handle Perplexity webhooks with signature validation and replay protection.
Prerequisites
- Perplexity webhook secret configured
- HTTPS endpoint accessible from internet
- Understanding of cryptographic signatures
- Redis or database for idempotency (optional)
Webhook Endpoint Setup
Express.js
import express from 'express';
import crypto from 'crypto';
const app = express();
// IMPORTANT: Raw body needed for signature verification
app.post('/webhooks/perplexity',
express.raw({ type: 'application/json' }),
async (req, res) => {
const signature = req.headers['x-perplexity-signature'] as string;
const timestamp = req.headers['x-perplexity-timestamp'] as string;
if (!verifyPerplexitySignature(req.body, signature, timestamp)) {
return res.status(401).json({ error: 'Invalid signature' });
}
const event = JSON.parse(req.body.toString());
await handlePerplexityEvent(event);
res.status(200).json({ received: true });
}
);
Signature Verification
function verifyPerplexitySignature(
payload: Buffer,
signature: string,
timestamp: string
): boolean {
const secret = process.env.PERPLEXITY_WEBHOOK_SECRET!;
// Reject old timestamps (replay attack protection)
const timestampAge = Date.now() - parseInt(timestamp) * 1000;
if (timestampAge > 300000) { // 5 minutes
console.error('Webhook timestamp too old');
return false;
}
// Compute expected signature
const signedPayload = `${timestamp}.${payload.toString()}`;
const expectedSignature = crypto
.createHmac('sha256', secret)
.update(signedPayload)
.digest('hex');
// Timing-safe comparison
return crypto.timingSafeEqual(
Buffer.from(signature),
Buffer.from(expectedSignature)
);
}
Event Handler Pattern
type PerplexityEventType = 'resource.created' | 'resource.updated' | 'resource.deleted';
interface PerplexityEvent {
id: string;
type: PerplexityEventType;
data: Record<string, any>;
created: string;
}
const eventHandlers: Record<PerplexityEventType, (data: any) => Promise<void>> = {
'resource.created': async (data) => { /* handle */ },
'resource.updated': async (data) => { /* handle */ },
'resource.deleted': async (data) => { /* handle */ }
};
async function handlePerplexityEvent(event: PerplexityEvent): Promise<void> {
const handler = eventHandlers[event.type];
if (!handler) {
console.log(`Unhandled event type: ${event.type}`);
return;
}
try {
await handler(event.data);
console.log(`Processed ${event.type}: ${event.id}`);
} catch (error) {
console.error(`Failed to process ${event.type}: ${event.id}`, error);
throw error; // Rethrow to trigger retry
}
}
Idempotency Handling
import { Redis } from 'ioredis';
const redis = new Redis(process.env.REDIS_URL);
async function isEventProcessed(eventId: string): Promise<boolean> {
const key = `perplexity:event:${eventId}`;
const exists = await redis.exists(key);
return exists === 1;
}
async function markEventProcessed(eventId: string): Promise<void> {
const key = `perplexity:event:${eventId}`;
await redis.set(key, '1', 'EX', 86400 * 7); // 7 days TTL
}
Webhook Testing
# Use Perplexity CLI to send test events
perplexity webhooks trigger resource.created --url http://localhost:3000/webhooks/perplexity
# Or use webhook.site for debugging
curl -X POST https://webhook.site/your-uuid \
-H "Content-Type: application/json" \
-d '{"type": "resource.created", "data": {}}'
Instructions
Step 1: Register Webhook Endpoint
Configure your webhook URL in the Perplexity dashboard.
Step 2: Implement Signature Verification
Use the signature verification code to validate incoming webhooks.
Step 3: Handle Events
Implement handlers for each event type your application needs.
Step 4: Add Idempotency
Prevent duplicate processing with event ID tracking.
Output
- Secure webhook endpoint
- Signature validation enabled
- Event handlers implemented
- Replay attack protection active
Error Handling
| Issue | Cause | Solution |
|---|---|---|
| Invalid signature | Wrong secret | Verify webhook secret |
| Timestamp rejected | Clock drift | Check server time sync |
| Duplicate events | Missing idempotency | Implement event ID tracking |
| Handler timeout | Slow processing | Use async queue |
Examples
Testing Webhooks Locally
# Use ngrok to expose local server
ngrok http 3000
# Send test webhook
curl -X POST https://your-ngrok-url/webhooks/perplexity \
-H "Content-Type: application/json" \
-d '{"type": "test", "data": {}}'
Resources
Next Steps
For performance optimization, see perplexity-performance-tuning.