Mask a Phone Call (Number Masking)

# server.py: Sinch Number Masking webhook server (Flask).
# Requires: pip install flask
# Env: SINCH_NUMBER, DESTINATION_NUMBER, PORT (optional, defaults to 3000)
import os
import sys
import json
from flask import Flask, request, jsonify

sinch_number       = os.environ.get("SINCH_NUMBER")
destination_number = os.environ.get("DESTINATION_NUMBER")

if not sinch_number or not destination_number:
    print("ERROR: SINCH_NUMBER and DESTINATION_NUMBER must be set.", file=sys.stderr)
    sys.exit(1)

app = Flask(__name__)

@app.route("/webhook", methods=["POST"])
def webhook():
    """Receives Sinch call events and responds with SVAML commands."""
    body  = request.get_json(force=True)
    event = body.get("event")
    call  = body.get("call", {})

    print(f"Received webhook event: {event}")
    print(json.dumps(call, indent=2))

    if event == "call.incoming":
        # Commands run directly at the top level; "callName" names the inbound
        # (caller) leg and "events.onHangup" handles the caller hanging up.
        return jsonify({
            "callName": "caller",
            "commands": [
                {"command": "answer"},
                {
                    "command": "messages",
                    "messagesName": "greeting",
                    "messages": [
                        {"type": "SAY", "say": {"text": "Please hold while we connect your call.", "voiceName": "Emma"}}
                    ]
                },
                # Add Party A to a named bridge
                {"command": "bridgeCall", "bridgeName": "main-bridge"},
                {
                    "command": "dial",
                    "callName": "callee",
                    # Party B sees the Sinch number
                    "from": {"type": "PHONE", "phone": {"number": sinch_number}},
                    # In production, look up the destination from your DB (call["to"])
                    "to":   {"type": "PHONE", "phone": {"number": destination_number}},
                    "dialTimeoutDurationSeconds": 30,
                    "events": {
                        "onAnswer": [{"command": "bridgeCall", "bridgeName": "main-bridge"}],
                        "onHangup": [{"command": "hangup", "callName": "caller"}]
                    }
                }
            ],
            "events": {"onHangup": [{"command": "hangup", "callName": "callee"}]}
        }), 200

    print(f"Unhandled event: {event}")
    return jsonify({"commands": []}), 200


if __name__ == "__main__":
    port = int(os.environ.get("PORT", 3000))
    print(f"Number masking webhook server listening on port {port}")
    app.run(host="0.0.0.0", port=port)

<?php
// server.php: Sinch Number Masking webhook server (Slim 4).
// Requires: composer require slim/slim slim/psr7 nyholm/psr7 php-di/php-di
// Env: SINCH_NUMBER, DESTINATION_NUMBER, PORT (optional, defaults to 3000)

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

require __DIR__ . '/vendor/autoload.php';

$sinchNumber       = getenv('SINCH_NUMBER')       ?: die("ERROR: SINCH_NUMBER not set.\n");
$destinationNumber = getenv('DESTINATION_NUMBER') ?: die("ERROR: DESTINATION_NUMBER not set.\n");

$app = AppFactory::create();
$app->addBodyParsingMiddleware();

// POST /webhook: receives Sinch call events and responds with SVAML
$app->post('/webhook', function (Request $request, Response $response) use ($sinchNumber, $destinationNumber) {
    $body  = $request->getParsedBody();
    $event = $body['event'] ?? null;
    $call  = $body['call']  ?? [];

    error_log("Received webhook event: {$event}");
    error_log(json_encode($call, JSON_PRETTY_PRINT));

    if ($event === 'call.incoming') {
        // Commands run directly at the top level; "callName" names the inbound
        // (caller) leg and "events.onHangup" handles the caller hanging up.
        $svaml = [
            'callName' => 'caller',
            'commands' => [
                ['command' => 'answer'],
                [
                    'command'      => 'messages',
                    'messagesName' => 'greeting',
                    'messages' => [
                        ['type' => 'SAY', 'say' => ['text' => 'Please hold while we connect your call.', 'voiceName' => 'Emma']],
                    ],
                ],
                // Add Party A to a named bridge
                ['command' => 'bridgeCall', 'bridgeName' => 'main-bridge'],
                [
                    'command'  => 'dial',
                    'callName' => 'callee',
                    // Party B sees the Sinch number
                    'from'    => ['type' => 'PHONE', 'phone' => ['number' => $sinchNumber]],
                    // In production, look up the destination from your DB ($call['to'])
                    'to'      => ['type' => 'PHONE', 'phone' => ['number' => $destinationNumber]],
                    'dialTimeoutDurationSeconds' => 30,
                    'events'  => [
                        'onAnswer' => [['command' => 'bridgeCall', 'bridgeName' => 'main-bridge']],
                        'onHangup' => [['command' => 'hangup', 'callName' => 'caller']],
                    ],
                ],
            ],
            'events' => [
                'onHangup' => [['command' => 'hangup', 'callName' => 'callee']],
            ],
        ];

        $response->getBody()->write(json_encode($svaml));
        return $response->withHeader('Content-Type', 'application/json')->withStatus(200);
    }

    error_log("Unhandled event: {$event}");
    $response->getBody()->write(json_encode(['commands' => []]));
    return $response->withHeader('Content-Type', 'application/json')->withStatus(200);
});

$app->run();

// Server.java: Sinch Number Masking webhook server (Spring Boot).
// Maven: spring-boot-starter-web
// Env: SINCH_NUMBER, DESTINATION_NUMBER, PORT (optional, defaults to 3000)

package com.sinch.tutorials.numbermasking;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@SpringBootApplication
@RestController
public class Server {

    private final String sinchNumber;
    private final String destinationNumber;

    public Server() {
        this.sinchNumber       = requireEnv("SINCH_NUMBER");
        this.destinationNumber = requireEnv("DESTINATION_NUMBER");
    }

    public static void main(String[] args) {
        String port = System.getenv().getOrDefault("PORT", "3000");
        System.setProperty("server.port", port);
        SpringApplication.run(Server.class, args);
        System.out.println("Number masking webhook server listening on port " + port);
    }

    /** POST /webhook: receives Sinch call events and responds with SVAML */
    @PostMapping("/webhook")
    public ResponseEntity<Map<String, Object>> webhook(@RequestBody Map<String, Object> body) {
        String event = (String) body.getOrDefault("event", "");
        Object call  = body.getOrDefault("call", Map.of());

        System.out.println("Received webhook event: " + event);
        System.out.println("Call: " + call);

        if ("call.incoming".equals(event)) {
            // Commands run directly at the top level; "callName" names the inbound
            // (caller) leg and "events.onHangup" handles the caller hanging up.
            Map<String, Object> svaml = Map.of(
                "callName", "caller",
                "commands", List.of(
                    Map.of("command", "answer"),
                    Map.of(
                        "command", "messages",
                        "messagesName", "greeting",
                        "messages", List.of(
                            Map.of("type", "SAY", "say", Map.of(
                                "text", "Please hold while we connect your call.",
                                "voiceName", "Emma"))
                        )
                    ),
                    // Add Party A to a named bridge
                    Map.of("command", "bridgeCall", "bridgeName", "main-bridge"),
                    Map.of(
                        "command", "dial",
                        "callName", "callee",
                        // Party B sees the Sinch number, not Party A's real number
                        "from", Map.of("type", "PHONE", "phone", Map.of("number", sinchNumber)),
                        // In production, look up from your DB based on the called Sinch number
                        "to",   Map.of("type", "PHONE", "phone", Map.of("number", destinationNumber)),
                        "dialTimeoutDurationSeconds", 30,
                        "events", Map.of(
                            "onAnswer", List.of(Map.of("command", "bridgeCall", "bridgeName", "main-bridge")),
                            "onHangup", List.of(Map.of("command", "hangup", "callName", "caller"))
                        )
                    )
                ),
                "events", Map.of(
                    "onHangup", List.of(Map.of("command", "hangup", "callName", "callee"))
                )
            );
            return ResponseEntity.ok(svaml);
        }

        System.out.println("Unhandled event: " + event);
        return ResponseEntity.ok(Map.of("commands", List.of()));
    }

    private static String requireEnv(String name) {
        String value = System.getenv(name);
        if (value == null || value.isBlank()) {
            System.err.println("ERROR: " + name + " is not set.");
            System.exit(1);
        }
        return value;
    }
}

// Demonstration only. Do not ship API keys to the browser.
(async function sinchMaskedBridgeCall() {
  const projectId    = "YOUR_PROJECT_ID";
  const keyId        = "YOUR_KEY_ID";
  const keySecret    = "YOUR_KEY_SECRET";
  const sinchNumber  = "+1XXXXXXXXXX";
  const partyANumber = "+1AAAAAAAAAA";  // First person to call
  const partyBNumber = "+1BBBBBBBBBB";  // Second person to connect

  const baseUrl    = "https://voice.api.sinch.com/v2";
  const authHeader = "Basic " + btoa(`${keyId}:${keySecret}`);

  const payload = {
    commands: [
      {
        command: "dial",
        callName: "party-a",
        from: { type: "PHONE", phone: { number: sinchNumber } },
        to:   { type: "PHONE", phone: { number: partyANumber } },
        dialTimeoutDurationSeconds: 30,
        events: {
          onAnswer: [
            {
              command: "messages",
              messagesName: "greeting",
              messages: [
                { type: "SAY", say: { text: "Please hold while we connect the other party.", voiceName: "Emma" } }
              ]
            },
            { command: "bridgeCall", bridgeName: "masked-bridge" },
            {
              command: "dial",
              callName: "party-b",
              from: { type: "PHONE", phone: { number: sinchNumber } },
              to:   { type: "PHONE", phone: { number: partyBNumber } },
              dialTimeoutDurationSeconds: 30,
              events: {
                onAnswer: [{ command: "bridgeCall", bridgeName: "masked-bridge" }],
                onHangup: [{ command: "hangup", callName: "party-a" }]
              }
            }
          ],
          onHangup: [{ command: "hangup", callName: "party-b" }]
        }
      }
    ]
  };

  const response = await fetch(`${baseUrl}/projects/${projectId}/calls`, {
    method: "POST",
    headers: { "Content-Type": "application/json", Authorization: authHeader },
    body: JSON.stringify(payload)
  });

  const data = await response.json();
  if (response.status === 201) {
    console.log("Bridge call created successfully:", data);
  } else {
    console.error(`ERROR ${response.status}:`, data);
  }
})();