Collega il tuo software alla tua inbox SyBox

curl -X POST https://api.smartsybox.com/v26.0/PHONE_NUMBER_ID/messages \
  -H "Authorization: Bearer YOUR_DEVICE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messaging_product": "whatsapp",
    "to": "15551234567",
    "type": "text",
    "text": { "body": "Hello from SyBox" }
  }'

Authorization: Bearer YOUR_KEY
Content-Type: application/json

curl -X POST https://api.smartsybox.com/v26.0/PHONE_NUMBER_ID/messages \
  -H "Authorization: Bearer YOUR_DEVICE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messaging_product": "whatsapp",
    "to": "15551234567",
    "type": "text",
    "text": { "body": "Hello from SyBox" }
  }'

const res = await fetch('https://api.smartsybox.com/v26.0/PHONE_NUMBER_ID/messages', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer ' + process.env.SYBOX_KEY,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    messaging_product: 'whatsapp',
    to: '15551234567',
    type: 'text',
    text: { body: 'Hello from SyBox' }
  })
});
console.log(res.status, await res.json());

import os, requests

r = requests.post(
    "https://api.smartsybox.com/v26.0/PHONE_NUMBER_ID/messages",
    headers={"Authorization": "Bearer " + os.environ["SYBOX_KEY"]},
    json={
        "messaging_product": "whatsapp",
        "to": "15551234567",
        "type": "text",
        "text": {"body": "Hello from SyBox"},
    },
    timeout=30,
)
print(r.status_code, r.json())

$ch = curl_init('https://api.smartsybox.com/v26.0/PHONE_NUMBER_ID/messages');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
    CURLOPT_HTTPHEADER     => [
        'Authorization: Bearer ' . getenv('SYBOX_KEY'),
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS     => json_encode([
        'messaging_product' => 'whatsapp',
        'to'                => '15551234567',
        'type'              => 'text',
        'text'              => ['body' => 'Hello from SyBox'],
    ]),
]);
echo curl_exec($ch);

using System.Net.Http.Headers;
using System.Text;

using var http = new HttpClient();   // in a real app, keep one HttpClient for the whole app
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("SYBOX_KEY"));

string json = """
{
  "messaging_product": "whatsapp",
  "to": "15551234567",
  "type": "text",
  "text": { "body": "Hello from SyBox" }
}
""";

var res = await http.PostAsync(
    "https://api.smartsybox.com/v26.0/PHONE_NUMBER_ID/messages",
    new StringContent(json, Encoding.UTF8, "application/json"));
Console.WriteLine(await res.Content.ReadAsStringAsync());

{
  "messaging_product": "whatsapp",
  "contacts": [{ "input": "15551234567", "wa_id": "15551234567" }],
  "messages": [{ "id": "wamid.HBgLMTU1NTEyMzQ1NjcVAgARGBI…" }]
}

{
  "messaging_product": "whatsapp",
  "to": "15551234567",
  "type": "template",
  "template": {
    "name": "order_shipped",
    "language": { "code": "en_US" },
    "components": [{
      "type": "body",
      "parameters": [{ "type": "text", "text": "#10432" }]
    }]
  }
}

{
  "messaging_product": "whatsapp",
  "to": "15551234567",
  "type": "image",
  "image": {
    "link": "https://example.com/invoice-10432.png",
    "caption": "Your invoice"
  }
}

{
  "error": {
    "message": "(#131030) Recipient phone number not in allowed list",
    "type": "OAuthException",
    "code": 131030
  }
}

{
  "error": {
    "message": "This key's daily send limit of 500 has been reached.",
    "type": "SyBoxGatewayError",
    "code": 429
  }
}

POST YOUR_ERP_URL
Authorization: Bearer YOUR_ERP_KEY
X-Sybox-Action: lookup
X-Sybox-Lang: en
X-Sybox-Theme: light
X-Sybox-Agent: 6f1c…
X-Sybox-Number: 104857600000000
Content-Type: application/json

{ "data": "{\"phone\":\"15551234567\",\"email\":\"customer@example.com\",\"ref\":\"\"}" }

{
  "renderAs": "table",
  "content": [
    { "Order": "#10432", "Status": "Shipped", "Total": "$1,250.00", "sybox_ref": "10432" },
    { "Order": "#10388", "Status": "Delivered", "Total": "$310.00", "sybox_ref": "10388" }
  ]
}

POST YOUR_ERP_URL
Authorization: Bearer YOUR_ERP_KEY
X-Sybox-Action: products

# the decoded "data":
{ "q": "wireless keyboard", "phone": "15551234567", "email": "customer@example.com", "ref": "" }

{
  "content": [
    {
      "name":      "Wireless Keyboard K380",
      "price":     449,
      "oldPrice":  520,
      "currency":  "USD",
      "available": true,
      "stock":     12,
      "image":     "https://cdn.example.com/k380.jpg",
      "link":      "https://shop.example.com/p/k380",
      "note":      "Ships in 24h"
    }
  ]
}

curl -X POST https://api.smartsybox.com/v1/case \
  -H "Authorization: Bearer $SYBOX_CASE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "customer_unique_id": "CUST-10432",
    "header": "Screen replacement not delivered",
    "description": "Paid on 12 Aug, promised in 3 days, still nothing.",
    "department_id": 5,
    "ext_ref": "TICKET-99817"
  }'

{
  "ok": true,
  "id": 8124,
  "number": 3042,
  "guid": "5f0c1e9a…",
  "customer_id": 771
}

curl -X POST https://api.smartsybox.com/v1/inbound \
  -H "Authorization: Bearer $SYBOX_INBOUND_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "phone": "15551234567",
    "text": "Order 4821 has left the warehouse.",
    "source": "Warehouse"
  }'

POST YOUR_WEBHOOK_URL
Content-Type: application/json
X-Hub-Signature-256: sha256=5d1f0c…
x-sybox-signature: sha256=5d1f0c…
x-sybox-event: message
x-sybox-timestamp: 1761400000

{
  "object": "whatsapp_business_account",
  "entry": [{
    "id": "WABA_ID",
    "changes": [{
      "field": "messages",
      "value": {
        "messaging_product": "whatsapp",
        "metadata": { "display_phone_number": "15550001111", "phone_number_id": "PHONE_NUMBER_ID" },
        "contacts": [{ "profile": { "name": "Sara" }, "wa_id": "15551234567" }],
        "messages": [{
          "from": "15551234567",
          "id": "wamid.HBgLMTU1NTEyMzQ1NjcVAgASGBQ…",
          "timestamp": "1761400000",
          "type": "text",
          "text": { "body": "Is my order shipped?" }
        }]
      }
    }]
  }]
}

{
  "object": "sybox",
  "event": "message",
  "channel": "telegram",
  "line": "8123456789",
  "workspace": "yourworkspace",
  "contact": { "key": "tg:6423115118", "name": "Sara" },
  "message": {
    "id": "812345",
    "timestamp": 1761400000,
    "type": "image",
    "text": "",
    "caption": "The broken part",
    "media": { "url": "https://api.smartsybox.com/…", "mime": "image/jpeg" }
  }
}

const crypto = require('crypto');

// express.raw: the signature is over the bytes as sent, so read them before any JSON parser.
app.post('/sybox/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sent = Buffer.from(req.get('X-Hub-Signature-256') || '');
  const want = Buffer.from('sha256=' + crypto
    .createHmac('sha256', process.env.SYBOX_WEBHOOK_SECRET)
    .update(req.body)
    .digest('hex'));
  if (sent.length !== want.length || !crypto.timingSafeEqual(sent, want)) return res.sendStatus(401);

  res.sendStatus(200);                       // answer first, then do the work
  const event = JSON.parse(req.body);
  const kind = req.get('x-sybox-event');     // message | status | reaction
});

$raw  = file_get_contents('php://input');
$want = 'sha256=' . hash_hmac('sha256', $raw, getenv('SYBOX_WEBHOOK_SECRET'));
$sent = $_SERVER['HTTP_X_HUB_SIGNATURE_256'] ?? '';

if (!hash_equals($want, $sent)) {
    http_response_code(401);
    exit;
}
http_response_code(200);
$event = json_decode($raw, true);
$kind  = $_SERVER['HTTP_X_SYBOX_EVENT'] ?? '';   // message | status | reaction

import hashlib, hmac, os
from flask import Flask, abort, request

app = Flask(__name__)

@app.post("/sybox/webhook")
def sybox_webhook():
    raw = request.get_data()
    want = "sha256=" + hmac.new(os.environ["SYBOX_WEBHOOK_SECRET"].encode(), raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(want, request.headers.get("X-Hub-Signature-256", "")):
        abort(401)
    event = request.get_json()
    kind = request.headers.get("x-sybox-event")   # message | status | reaction
    return "", 200

using System.Security.Cryptography;
using System.Text;

app.MapPost("/sybox/webhook", async (HttpRequest req) =>
{
    using var ms = new MemoryStream();
    await req.Body.CopyToAsync(ms);
    byte[] raw = ms.ToArray();

    string secret = Environment.GetEnvironmentVariable("SYBOX_WEBHOOK_SECRET")!;
    byte[] mac = HMACSHA256.HashData(Encoding.UTF8.GetBytes(secret), raw);
    byte[] want = Encoding.ASCII.GetBytes("sha256=" + Convert.ToHexString(mac).ToLowerInvariant());
    byte[] sent = Encoding.ASCII.GetBytes(req.Headers["X-Hub-Signature-256"].ToString());
    if (!CryptographicOperations.FixedTimeEquals(want, sent)) return Results.Unauthorized();

    string kind = req.Headers["x-sybox-event"];   // message | status | reaction
    return Results.Ok();
});

<script async src="https://api.smartsybox.com/lc/w.js" data-key="lcpk_YOUR_PUBLIC_KEY"></script>

function b64url(string $s): string { return rtrim(strtr(base64_encode($s), '+/', '-_'), '='); }

$header  = b64url(json_encode(['alg' => 'HS256', 'typ' => 'JWT']));
$payload = b64url(json_encode([
    'sub'   => (string) $user->id,
    'name'  => $user->name,
    'email' => $user->email,
    'exp'   => time() + 600,          // ten minutes
]));
$signature = b64url(hash_hmac('sha256', "$header.$payload", getenv('SYBOX_LC_SIGNING_KEY'), true));
$token = "$header.$payload.$signature";

const crypto = require('crypto');
const b64url = (s) => Buffer.from(s).toString('base64url');

const header = b64url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }));
const payload = b64url(JSON.stringify({
  sub: String(user.id),
  name: user.name,
  email: user.email,
  exp: Math.floor(Date.now() / 1000) + 600     // ten minutes
}));
const signature = crypto.createHmac('sha256', process.env.SYBOX_LC_SIGNING_KEY)
  .update(header + '.' + payload).digest('base64url');
const token = header + '.' + payload + '.' + signature;

import base64, hashlib, hmac, json, os, time

def b64url(b: bytes) -> str:
    return base64.urlsafe_b64encode(b).rstrip(b"=").decode()

header = b64url(json.dumps({"alg": "HS256", "typ": "JWT"}).encode())
payload = b64url(json.dumps({
    "sub": str(user.id),
    "name": user.name,
    "email": user.email,
    "exp": int(time.time()) + 600,   # ten minutes
}).encode())
key = os.environ["SYBOX_LC_SIGNING_KEY"].encode()
signature = b64url(hmac.new(key, f"{header}.{payload}".encode(), hashlib.sha256).digest())
token = f"{header}.{payload}.{signature}"

using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

static string B64Url(byte[] b) => Convert.ToBase64String(b).TrimEnd('=').Replace('+', '-').Replace('/', '_');

string header = B64Url(JsonSerializer.SerializeToUtf8Bytes(new { alg = "HS256", typ = "JWT" }));
string payload = B64Url(JsonSerializer.SerializeToUtf8Bytes(new {
    sub = user.Id.ToString(),
    name = user.Name,
    email = user.Email,
    exp = DateTimeOffset.UtcNow.AddMinutes(10).ToUnixTimeSeconds()
}));
byte[] key = Encoding.UTF8.GetBytes(Environment.GetEnvironmentVariable("SYBOX_LC_SIGNING_KEY"));
string signature = B64Url(HMACSHA256.HashData(key, Encoding.ASCII.GetBytes(header + "." + payload)));
string token = header + "." + payload + "." + signature;

<script>
  window.SyBoxChatConfig = { identity: "TOKEN_FROM_YOUR_SERVER", locale: "en" };
</script>
<script async src="https://api.smartsybox.com/lc/w.js" data-key="lcpk_YOUR_PUBLIC_KEY"></script>

SyBoxChat('open');                       // open the chat
SyBoxChat('close');                      // close it
SyBoxChat('identify', token);            // after a sign-in without a page reload
SyBoxChat('locale', 'fr');               // the chat's language
SyBoxChat('on', 'message', function (m) {
  // a reply arrived
});
SyBoxChat('on', 'open', function () { /* the chat opened */ });
SyBoxChat('on', 'close', function () { /* the chat closed */ });

// Before the chat's code, every setting is optional:
window.SyBoxChatConfig = {
  identity: 'TOKEN_FROM_YOUR_SERVER',    // a signed-in user (see above)
  name: 'Sara', email: 'sara@example.com', // a visitor without an account: fills the form for them
  locale: 'ar',
  serviceWorker: 'auto'                   // 'auto' | '/your-sw.js' | 'site' | 'off'
};

try { importScripts('https://api.smartsybox.com/lc/sw.js'); } catch (e) {}

curl -X POST https://api.smartsybox.com/v1/livechat/messages \
  -H "Authorization: Bearer $SYBOX_LC_SERVER_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user":    { "id": "u42", "name": "Sara Ali", "email": "sara@example.com", "locale": "ar" },
    "message": { "client_id": "a1b2c3", "text": "Hi, is my order on its way?", "reply_to": "" }
  }'

{ "ok": 1, "id": 981, "guid": "7c9e…", "duplicate": 0 }

{ "user_id": "u42", "up_to": 990 }                 // read
{ "user_id": "u42", "id": 981, "text": "…" }        // edit
{ "user_id": "u42", "id": 981 }                     // delete
{ "user_id": "u42", "id": 990, "emoji": "👍" }      // react
{ "user_id": "u42", "on": 1 }                       // typing

{
  "id": 990,
  "guid": "b81d…",
  "dir": "out",                       // "in" = your user wrote it, "out" = your team
  "type": "image",                    // text | image | audio | video | file
  "text": "Here is the tracking page",
  "media": { "url": "https://api.smartsybox.com/…", "mime": "image/png", "name": "tracking.png", "w": 1080, "h": 720 },
                                       // a voice note or a video also has "secs"
  "status": 3,                         // on your user's messages: 1 received, 3 read by an agent
  "reply_to": "7c9e…",
  "client": "a1b2c3",                  // on your user's messages: the client_id you sent
  "react_us": "",                      // your team's reaction on it
  "react_me": "👍",                    // your user's reaction on it
  "at": "2026-10-25T09:41:07Z",
  "edited": 0
}

const crypto = require('crypto');

app.post('/sybox/livechat', express.raw({ type: 'application/json' }), (req, res) => {
  const parts = Object.fromEntries((req.get('x-sybox-signature') || '').split(',').map(p => p.split('=')));
  const t = Number(parts.t);
  if (!t || Math.abs(Date.now() / 1000 - t) > 300) return res.sendStatus(401);   // older than five minutes

  const want = Buffer.from(crypto.createHmac('sha256', process.env.SYBOX_LC_REPLY_KEY)
    .update(t + '.').update(req.body).digest('hex'));
  const sent = Buffer.from(parts.v1 || '');
  if (sent.length !== want.length || !crypto.timingSafeEqual(sent, want)) return res.sendStatus(401);

  res.sendStatus(200);
  const delivery = req.get('x-sybox-delivery');   // seen it already? ignore
  const evt = JSON.parse(req.body);               // { event, line_id, user_id, message | message_id | read_id }
});

$raw = file_get_contents('php://input');
parse_str(str_replace(',', '&', $_SERVER['HTTP_X_SYBOX_SIGNATURE'] ?? ''), $sig);
$t = (int) ($sig['t'] ?? 0);

$want = hash_hmac('sha256', $t . '.' . $raw, getenv('SYBOX_LC_REPLY_KEY'));
if (abs(time() - $t) > 300 || !hash_equals($want, $sig['v1'] ?? '')) {
    http_response_code(401);
    exit;
}
http_response_code(200);
$delivery = $_SERVER['HTTP_X_SYBOX_DELIVERY'] ?? '';   // seen it already? ignore
$evt = json_decode($raw, true);

import hashlib, hmac, os, time
from flask import abort, request

@app.post("/sybox/livechat")
def sybox_livechat():
    raw = request.get_data()
    sig = dict(p.split("=", 1) for p in request.headers.get("x-sybox-signature", "").split(",") if "=" in p)
    t = int(sig["t"]) if sig.get("t", "").isdigit() else 0   # a malformed header is a 401, not a crash
    want = hmac.new(os.environ["SYBOX_LC_REPLY_KEY"].encode(), f"{t}.".encode() + raw, hashlib.sha256).hexdigest()
    if abs(time.time() - t) > 300 or not hmac.compare_digest(want, sig.get("v1", "")):
        abort(401)
    delivery = request.headers.get("x-sybox-delivery")   # seen it already? ignore
    evt = request.get_json()
    return "", 200

using System.Security.Cryptography;
using System.Text;

app.MapPost("/sybox/livechat", async (HttpRequest req) =>
{
    using var ms = new MemoryStream();
    await req.Body.CopyToAsync(ms);
    byte[] raw = ms.ToArray();

    var sig = new Dictionary<string, string>();
    foreach (var part in req.Headers["x-sybox-signature"].ToString().Split(','))
    {
        var kv = part.Split('=', 2);
        if (kv.Length == 2) sig[kv[0].Trim()] = kv[1].Trim();   // a malformed header is a 401, not a crash
    }
    if (!long.TryParse(sig.GetValueOrDefault("t"), out long t) ||
        Math.Abs(DateTimeOffset.UtcNow.ToUnixTimeSeconds() - t) > 300) return Results.Unauthorized();

    byte[] signedBytes = Encoding.ASCII.GetBytes(t + ".").Concat(raw).ToArray();
    string replyKey = Environment.GetEnvironmentVariable("SYBOX_LC_REPLY_KEY")!;
    byte[] mac = HMACSHA256.HashData(Encoding.UTF8.GetBytes(replyKey), signedBytes);
    byte[] want = Encoding.ASCII.GetBytes(Convert.ToHexString(mac).ToLowerInvariant());
    byte[] sent = Encoding.ASCII.GetBytes(sig.GetValueOrDefault("v1", ""));
    if (!CryptographicOperations.FixedTimeEquals(want, sent)) return Results.Unauthorized();

    return Results.Ok();
});