Mask an incoming call phone number with ASP.NET Core 6.0

If you're creating an app that connects strangers to each other, it's very likely you'll want to hide the phone numbers of the users of the app from each other, to keep information private and everyone involved safe and secure. Using the Voice API and the Sinch SDK for C#, this guide will show you how to easily connect two users through one Sinch number with just a few lines of code.

What you need to know before you start

Before you can get started, you need the following already set up:

• Set all Voice API configuration settings.
• ASP.NET Core 6.0 or later SDK and ASP.NET Core Runtime and a familiarity with how to create an app.
• ngrok and a familiarity with how to start a network tunnel. You can use any method you want to make your server accessible over the internet, but we like ngrok and it's what we'll use in this guide.
• Postman or another method of making API requests to a server on your machine. You can use whatever you like, but Postman makes things easy, and it's what we'll use in this guide.
• Two mobile phone handsets you can use to test. This isn't strictly necessary, but you can get more of an end-to-end experience of the entire process.

Set up your ASP.NET Core 6.0 application

Create a new project folder and open a command prompt. Execute the following command to create a new ASP.NET Core 6.0 web API application:

dotnet new webapi

This creates a new web API application and project. Now add the Sinch Voice SDK. Run the following command:

dotnet add package Sinch.ServerSdk

The Voice SDK lets you use the Voice API with far fewer lines of code than you'd otherwise need.

Set up your file

using Sinch.ServerSdk;
using Sinch.ServerSdk.Calling.Models;
using Sinch.ServerSdk.Models;

var builder = WebApplication.CreateBuilder(args);
builder.Services.Configure<Microsoft.AspNetCore.Http.Json.JsonOptions>(o =>
{
    o.SerializerOptions.DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingDefault;
    o.SerializerOptions.PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase;
    o.SerializerOptions.PropertyNameCaseInsensitive = true;
});

var app = builder.Build();
var numberConfigs = new List<NumberConfig>();
app.MapPost("/configure", (string from, string to) => {
    numberConfigs.RemoveAll(n => n.From == from);
    var config = new NumberConfig {
        From = from,
        To = to
    };
    numberConfigs.Add(config);
    return Results.Created("/configure", config);
});

app.MapGet("/configure", () => numberConfigs);

app.MapPost("/incoming-call", (CallbackEventModel model) => {
    var sinch = SinchFactory.CreateCallbackResponseFactory(Locale.EnUs);
    var builder = sinch.CreateIceSvamletBuilder();
    if (model.Event == "ice"){
        var config = numberConfigs.FirstOrDefault();
        builder.ConnectPstn(config.To)
               .WithCli(model.To.Endpoint)
               .WithoutCallbacks();
    
    }
    return builder.Build().Model;
});
app.Run("http://localhost:3000");

public class NumberConfig
{
    public string From { get; set; }
    public string To { get; set; }
}

This code starts a lightweight web API server listening on the localhost of your machine. It also contains the logic necessary to handle the following tasks:

• Create a configuration object that determines what number will be displayed as the "from" when a number calls.
• View the current configuration object data.
• Listen for callbacks from the Sinch servers that indicate a phone call is incoming and use the configuration object to mask the phone number.

We'll go through and cover each of those functions in detail, but first let's start the server and the network tunnel so we can configure the callback URL in the app on the dashboard.

Start your server

Start your server with the following command:

dotnet run

Start your ngrok tunnel

At this point you need to start your ngrok tunnel so that the Sinch servers can access the webserver running on your local machine. Run the following command to start your tunnel:

ngrok http 3000

This starts a tunnel to your webserver, which is running on port 3000 of your localhost.

Navigate to your app on your dashboard. Under the Settings section, you'll see a field labeled "Callback URL." Paste your ngrok URL into that field and click Save.

Also take note of the Sinch phone number you have assigned to this app, as you'll be calling that number in another step.

With that done, now we can create a configuration object to hold the phone number we want to mask.

Create a number configuration object

To create this configuration object, you'll be making a POST request to the server running on your local host, with the numbers you want to use in your query. Using Postman, make the following POST request:

http://localhost:3000/configure?from=<from-phone-number>&to=<to-phone-number>

Mask a phone call

Next steps

• API specification