Webhooks

curl -X POST https://api.zapsterapi.com/v1/wa/instances/PRIMEIRA_INSTANCIA/webhooks \
  -H "Authorization: Bearer SEU_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://sua-app.com/webhook",
    "name": "Webhook de produção",
    "events": ["message.received", "message.sent"]
  }'

const response = await fetch(
  'https://api.zapsterapi.com/v1/wa/instances/PRIMEIRA_INSTANCIA/webhooks',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer SEU_TOKEN',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      url: 'https://sua-app.com/webhook',
      name: 'Webhook de produção',
      events: ['message.received', 'message.sent'],
    }),
  },
);

const data = await response.json();
console.log(data);
// A resposta traz o id do webhook criado, que você reaproveita nas próximas instâncias.
// { "webhook_id": "2nenz69l0xbf0m3uu9tfo", ... }

// Node.js 18+ (fetch nativo). Guarde o token em variável de ambiente.
const response = await fetch(
  'https://api.zapsterapi.com/v1/wa/instances/PRIMEIRA_INSTANCIA/webhooks',
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.ZAPSTER_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      url: 'https://sua-app.com/webhook',
      name: 'Webhook de produção',
      events: ['message.received', 'message.sent'],
    }),
  },
);

const { webhook_id } = await response.json();
console.log('Webhook criado:', webhook_id);

<?php
$ch = curl_init('https://api.zapsterapi.com/v1/wa/instances/PRIMEIRA_INSTANCIA/webhooks');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer SEU_TOKEN',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'url' => 'https://sua-app.com/webhook',
        'name' => 'Webhook de produção',
        'events' => ['message.received', 'message.sent'],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
echo $data['webhook_id'];

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	body, _ := json.Marshal(map[string]any{
		"url":    "https://sua-app.com/webhook",
		"name":   "Webhook de produção",
		"events": []string{"message.received", "message.sent"},
	})

	req, _ := http.NewRequest(
		http.MethodPost,
		"https://api.zapsterapi.com/v1/wa/instances/PRIMEIRA_INSTANCIA/webhooks",
		bytes.NewReader(body),
	)
	req.Header.Set("Authorization", "Bearer SEU_TOKEN")
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	data, _ := io.ReadAll(resp.Body)
	fmt.Println(string(data))
}

import requests

response = requests.post(
    "https://api.zapsterapi.com/v1/wa/instances/PRIMEIRA_INSTANCIA/webhooks",
    headers={"Authorization": "Bearer SEU_TOKEN"},
    json={
        "url": "https://sua-app.com/webhook",
        "name": "Webhook de produção",
        "events": ["message.received", "message.sent"],
    },
)

data = response.json()
print(data["webhook_id"])

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class CreateWebhook {
    public static void main(String[] args) throws Exception {
        String body = """
            {
              "url": "https://sua-app.com/webhook",
              "name": "Webhook de produção",
              "events": ["message.received", "message.sent"]
            }
            """;

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.zapsterapi.com/v1/wa/instances/PRIMEIRA_INSTANCIA/webhooks"))
            .header("Authorization", "Bearer SEU_TOKEN")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

require "net/http"
require "json"
require "uri"

uri = URI("https://api.zapsterapi.com/v1/wa/instances/PRIMEIRA_INSTANCIA/webhooks")

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer SEU_TOKEN"
request["Content-Type"] = "application/json"
request.body = {
  url: "https://sua-app.com/webhook",
  name: "Webhook de produção",
  events: ["message.received", "message.sent"]
}.to_json

response = http.request(request)
data = JSON.parse(response.body)
puts data["webhook_id"]

curl -X POST https://api.zapsterapi.com/v1/wa/instances/SEGUNDA_INSTANCIA/webhooks \
  -H "Authorization: Bearer SEU_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "webhook_id": "2nenz69l0xbf0m3uu9tfo",
    "events": ["message.received"]
  }'

const response = await fetch(
  'https://api.zapsterapi.com/v1/wa/instances/SEGUNDA_INSTANCIA/webhooks',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer SEU_TOKEN',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      webhook_id: '2nenz69l0xbf0m3uu9tfo',
      events: ['message.received'],
    }),
  },
);

const data = await response.json();
console.log(data);

// Node.js 18+ (fetch nativo).
const response = await fetch(
  'https://api.zapsterapi.com/v1/wa/instances/SEGUNDA_INSTANCIA/webhooks',
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.ZAPSTER_TOKEN}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      webhook_id: '2nenz69l0xbf0m3uu9tfo',
      events: ['message.received'],
    }),
  },
);

console.log(await response.json());

<?php
$ch = curl_init('https://api.zapsterapi.com/v1/wa/instances/SEGUNDA_INSTANCIA/webhooks');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer SEU_TOKEN',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'webhook_id' => '2nenz69l0xbf0m3uu9tfo',
        'events' => ['message.received'],
    ]),
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	body, _ := json.Marshal(map[string]any{
		"webhook_id": "2nenz69l0xbf0m3uu9tfo",
		"events":     []string{"message.received"},
	})

	req, _ := http.NewRequest(
		http.MethodPost,
		"https://api.zapsterapi.com/v1/wa/instances/SEGUNDA_INSTANCIA/webhooks",
		bytes.NewReader(body),
	)
	req.Header.Set("Authorization", "Bearer SEU_TOKEN")
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	data, _ := io.ReadAll(resp.Body)
	fmt.Println(string(data))
}

import requests

response = requests.post(
    "https://api.zapsterapi.com/v1/wa/instances/SEGUNDA_INSTANCIA/webhooks",
    headers={"Authorization": "Bearer SEU_TOKEN"},
    json={
        "webhook_id": "2nenz69l0xbf0m3uu9tfo",
        "events": ["message.received"],
    },
)

print(response.json())

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ReuseWebhook {
    public static void main(String[] args) throws Exception {
        String body = """
            {
              "webhook_id": "2nenz69l0xbf0m3uu9tfo",
              "events": ["message.received"]
            }
            """;

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.zapsterapi.com/v1/wa/instances/SEGUNDA_INSTANCIA/webhooks"))
            .header("Authorization", "Bearer SEU_TOKEN")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

require "net/http"
require "json"
require "uri"

uri = URI("https://api.zapsterapi.com/v1/wa/instances/SEGUNDA_INSTANCIA/webhooks")

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer SEU_TOKEN"
request["Content-Type"] = "application/json"
request.body = {
  webhook_id: "2nenz69l0xbf0m3uu9tfo",
  events: ["message.received"]
}.to_json

puts http.request(request).body

// Node.js + Express
app.post('/webhook', (req, res) => {
  const instanceId = req.headers['x-instance-id']
  const messageId = req.headers['x-message-id']
  const attemptCount = req.headers['x-attempt-count']

  console.log(`Notificação recebida da instância ${instanceId}`)
  console.log(`ID da mensagem: ${messageId}, tentativa: ${attemptCount}`)

  // Valide a origem antes de processar
  if (!instanceId) {
    return res.status(400).json({ error: 'Cabeçalho X-Instance-ID ausente' })
  }

  // Processe o evento
  const event = req.body
  console.log(`Evento: ${event.type}`, event.data)

  res.status(200).json({ received: true })
})

<?php
// Cabeçalhos chegam em $_SERVER com o prefixo HTTP_ e underscore no lugar do hífen
$instanceId = $_SERVER['HTTP_X_INSTANCE_ID'] ?? null;
$messageId = $_SERVER['HTTP_X_MESSAGE_ID'] ?? null;
$attemptCount = $_SERVER['HTTP_X_ATTEMPT_COUNT'] ?? null;

error_log("Notificação recebida da instância {$instanceId}");
error_log("ID da mensagem: {$messageId}, tentativa: {$attemptCount}");

// Valide a origem antes de processar
if (!$instanceId) {
    http_response_code(400);
    echo json_encode(['error' => 'Cabeçalho X-Instance-ID ausente']);
    exit;
}

// Processe o evento
$event = json_decode(file_get_contents('php://input'), true);
error_log("Evento: {$event['type']}");

http_response_code(200);
echo json_encode(['received' => true]);

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	instanceID := r.Header.Get("X-Instance-ID")
	messageID := r.Header.Get("X-Message-ID")
	attemptCount := r.Header.Get("X-Attempt-Count")

	log.Printf("Notificação recebida da instância %s", instanceID)
	log.Printf("ID da mensagem: %s, tentativa: %s", messageID, attemptCount)

	// Valide a origem antes de processar
	if instanceID == "" {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]string{"error": "Cabeçalho X-Instance-ID ausente"})
		return
	}

	// Processe o evento
	var event map[string]any
	json.NewDecoder(r.Body).Decode(&event)
	log.Printf("Evento: %v", event["type"])

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

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.post("/webhook")
def webhook():
    instance_id = request.headers.get("X-Instance-ID")
    message_id = request.headers.get("X-Message-ID")
    attempt_count = request.headers.get("X-Attempt-Count")

    print(f"Notificação recebida da instância {instance_id}")
    print(f"ID da mensagem: {message_id}, tentativa: {attempt_count}")

    # Valide a origem antes de processar
    if not instance_id:
        return jsonify(error="Cabeçalho X-Instance-ID ausente"), 400

    # Processe o evento
    event = request.get_json()
    print(f"Evento: {event['type']}", event["data"])

    return jsonify(received=True), 200

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.Map;

@RestController
public class WebhookController {

    @PostMapping("/webhook")
    public ResponseEntity<?> receive(
            @RequestHeader(value = "X-Instance-ID", required = false) String instanceId,
            @RequestHeader(value = "X-Message-ID", required = false) String messageId,
            @RequestHeader(value = "X-Attempt-Count", required = false) String attemptCount,
            @RequestBody Map<String, Object> event) {

        System.out.printf("Notificação recebida da instância %s%n", instanceId);
        System.out.printf("ID da mensagem: %s, tentativa: %s%n", messageId, attemptCount);

        // Valide a origem antes de processar
        if (instanceId == null) {
            return ResponseEntity.badRequest().body(Map.of("error", "Cabeçalho X-Instance-ID ausente"));
        }

        // Processe o evento
        System.out.println("Evento: " + event.get("type"));

        return ResponseEntity.ok(Map.of("received", true));
    }
}

require "sinatra"
require "json"

post "/webhook" do
  instance_id = request.env["HTTP_X_INSTANCE_ID"]
  message_id = request.env["HTTP_X_MESSAGE_ID"]
  attempt_count = request.env["HTTP_X_ATTEMPT_COUNT"]

  puts "Notificação recebida da instância #{instance_id}"
  puts "ID da mensagem: #{message_id}, tentativa: #{attempt_count}"

  # Valide a origem antes de processar
  halt 400, { error: "Cabeçalho X-Instance-ID ausente" }.to_json if instance_id.nil?

  # Processe o evento
  event = JSON.parse(request.body.read)
  puts "Evento: #{event['type']}"

  content_type :json
  { received: true }.to_json
end