Webhooks: Quick Reference

{
  "event": "generation.completed",
  "timestamp": "ISO 8601 timestamp",
  "webhook_id": "webhook identifier",
  "generation_id": "generation ID",
  "data": {
    "state": "Success|Failed",
    "stateMessage": "Human readable status",
    "request": { /* Original request with metadata */ },
    "response": { /* OpenAI format response */ },
    "finishedAt": "ISO 8601 timestamp"
  }
}

{
  "event": "async-embedding.completed",
  "timestamp": "ISO 8601 timestamp",
  "webhook_id": "webhook identifier",
  "generation_id": "generation ID",
  "data": {
    "state": "Success|Failed",
    "stateMessage": "Human readable status",
    "request": { /* Original embeddings request with metadata */ },
    "response": { /* OpenAI format embeddings response */ },
    "finishedAt": "ISO 8601 timestamp"
  }
}

{
  "event": "slow-group.completed",
  "timestamp": "ISO 8601 timestamp",
  "group_id": "group ID",
  "data": {
    "group_size": 2,
    "status": "completed",
    "generations": [
      {
        "generationId": "generation ID",
        "state": "Success|Failed",
        "stateMessage": "Human readable status",
        "request": { /* Original request */ },
        "response": { /* OpenAI format response */ },
        "finishedAt": "ISO 8601 timestamp or null"
      }
    ]
  }
}

curl -X POST https://api.inference.net/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/llama-3.1-8b-instruct",
    "messages": [{"role": "user", "content": "Hello!"}],
    "metadata": {"webhook_id": "YOUR_WEBHOOK_IDENTIFIER"}
  }'

curl -X POST https://api.inference.net/v1/async/embeddings \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen/qwen3-embedding-4b",
    "input": ["Text to embed", "Another text to embed"],
    "metadata": {"webhook_id": "YOUR_WEBHOOK_IDENTIFIER"}
  }'

app.post('/webhook', express.json(), (req, res) => {
  res.status(200).json({ received: true });

  if (req.body.event === 'generation.completed') {
    // Process asynchronously
    setImmediate(() => {
      console.log('Generation completed:', req.body.generation_id);
      // Your processing logic here
    });
  } else if (req.body.event === 'async-embedding.completed') {
    // Process embedding completion asynchronously
    setImmediate(() => {
      console.log('Embedding completed:', req.body.generation_id);
      console.log('Number of embeddings:', req.body.data.response.data.length);
      // Your processing logic here
    });
  } else if (req.body.event === 'slow-group.completed') {
    // Process group completion asynchronously
    setImmediate(() => {
      console.log('Group completed:', req.body.group_id);
      console.log('Group size:', req.body.data.group_size);
      req.body.data.generations.forEach(gen => {
        console.log(`Generation ${gen.generationId}: ${gen.state}`);
      });
      // Your processing logic here
    });
  }
});

@app.post("/webhook")
async def handle_webhook(payload: dict, background_tasks: BackgroundTasks):
    background_tasks.add_task(process_webhook, payload)
    return {"received": True}

def process_webhook(payload):
    if payload["event"] == "generation.completed":
        print(f"Processing generation {payload['generation_id']}")
        # Your processing logic here
    elif payload["event"] == "async-embedding.completed":
        print(f"Processing embedding {payload['generation_id']}")
        print(f"Number of embeddings: {len(payload['data']['response']['data'])}")
        # Your processing logic here
    elif payload["event"] == "slow-group.completed":
        print(f"Processing group {payload['group_id']}")
        print(f"Group size: {payload['data']['group_size']}")
        for gen in payload["data"]["generations"]:
            print(f"Generation {gen['generationId']}: {gen['state']}")
        # Your processing logic here

func handleWebhook(w http.ResponseWriter, r *http.Request) {
    var payload map[string]interface{}
    json.NewDecoder(r.Body).Decode(&payload)

    // Process asynchronously
    go func() {
        switch payload["event"] {
        case "generation.completed":
            // Process single generation
        case "async-embedding.completed":
            // Process embedding completion
            fmt.Printf("Embedding %s completed\n", payload["generation_id"])
            data := payload["data"].(map[string]interface{})
            response := data["response"].(map[string]interface{})
            embeddings := response["data"].([]interface{})
            fmt.Printf("Number of embeddings: %d\n", len(embeddings))
            // Your processing logic here
        case "slow-group.completed":
            data := payload["data"].(map[string]interface{})
            fmt.Printf("Group %s completed with %v generations\n",
                payload["group_id"], data["group_size"])
            // Your processing logic here
        }
    }()

    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]bool{"received": true})
}