Integrating .NET Core API with WhatsApp for Push Notification

Introduction

In the digital age, communication has transcended traditional boundaries, enabling instantaneous connections across the globe. WhatsApp, one of the most popular messaging platforms, offers a robust API that allows developers to integrate its messaging capabilities into their applications. This integration can significantly enhance user engagement through automated notifications and interactive messaging services. In this article, we will explore how to integrate a .NET Core API with the WhatsApp API to implement push notification functionalities.

Setting Up Your Development Environment

Before diving into the integration process, setting up a proper development environment is crucial. Follow these steps to ensure you have all the necessary tools:

Install .NET Core SDK: Download and install the .NET Core SDK from the official .NET Core website. This will enable you to create and run .NET Core applications.
Choose an IDE: Use an Integrated Development Environment (IDE) like Visual Studio or Visual Studio Code for a more streamlined development experience. Visual Studio provides a rich set of features specifically tailored for .NET development, while Visual Studio Code offers a lightweight and versatile option.

Creating a New .NET Core API Project

Once your development environment is set up, you can create a new .NET Core API project. Open your terminal or command prompt and run the following commands:

dotnet new webapi -n WhatsAppNotificationApi
cd WhatsAppNotificationApi

This will create a new Web API project named WhatsAppNotificationApi and navigate into the project directory.

Adding Necessary Packages

You'll need to add some essential packages to your project to interact with the WhatsApp API. These include packages for making HTTP requests and handling JSON data. Use the following commands to add the required packages:

dotnet add package Microsoft.Extensions.Http
dotnet add package Newtonsoft.Json

The Microsoft.Extensions.Http Package provides robust HTTP client functionality while Newtonsoft.Json is a popular library for JSON serialization and deserialization.

Setting Up WhatsApp API Access

Integrating with the WhatsApp API requires access credentials, which you can obtain by signing up with a service like Twilio. Twilio provides comprehensive WhatsApp API services, including messaging capabilities. Follow these steps to set up your WhatsApp API access:

Sign Up for Twilio: Visit the Twilio website and sign up for an account. Twilio offers a free trial that includes some initial credits to get you started.
Get API Credentials: Navigate to the Twilio Console and locate your Account SID and Auth Token after signing up. These credentials are necessary for authenticating API requests.
WhatsApp Sandbox: If you are using Twilio, set up a WhatsApp sandbox environment. This allows you to test your integration before going live. Follow Twilio's instructions to configure the sandbox and connect your phone number.

Creating a Configuration Class

Create a configuration class to manage your WhatsApp API credentials and settings efficiently. This class will store the API URL and authentication details. Add the following code to your project:

public class WhatsAppSettings
{
    public string ApiUrl { get; set; }
    public string ApiKey { get; set; }
}

Configuring AppSettings.json

Next, configure your appsettings.json file to include the WhatsApp API settings. Open the file and add the following section:

{
    "WhatsAppSettings": {
        "ApiUrl": "https://api.whatsapp.com/send",
        "ApiKey": "your_api_key"
    }
}

Replace "your_api_key" with your actual API key obtained from Twilio or your chosen service provider.

Creating a Service for WhatsApp Notifications

With your configuration in place, it's time to create a service that will handle sending notifications through WhatsApp. Implement the following interface and class:

public interface IWhatsAppService
{
    Task<bool> SendMessageAsync(string phoneNumber, string message);
}

public class WhatsAppService : IWhatsAppService
{
    private readonly HttpClient _httpClient;
    private readonly WhatsAppSettings _settings;

    public WhatsAppService(HttpClient httpClient, IOptions<WhatsAppSettings> settings)
    {
        _httpClient = httpClient;
        _settings = settings.Value;
    }

    public async Task<bool> SendMessageAsync(string phoneNumber, string message)
    {
        var requestUrl = $"{_settings.ApiUrl}?phone={phoneNumber}&text={message}&key={_settings.ApiKey}";
        var response = await _httpClient.GetAsync(requestUrl);

        return response.IsSuccessStatusCode;
    }
}

This service uses HttpClient to send GET requests to the WhatsApp API, passing the phone number, message, and API key as query parameters.

Registering the Service in Startup.cs

To enable dependency injection, register your WhatsApp service in Startup.cs. Open the file and modify the ConfigureServices method as follows:

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<WhatsAppSettings>(Configuration.GetSection("WhatsAppSettings"));
    services.AddHttpClient<IWhatsAppService, WhatsAppService>();
    services.AddControllers();
}

Creating a Controller to Handle Requests

With the service registered, create a controller to handle API requests and send notifications. Add the following code to a new controller file:

[ApiController]
[Route("[controller]")]
public class NotificationsController : ControllerBase
{
    private readonly IWhatsAppService _whatsAppService;

    public NotificationsController(IWhatsAppService whatsAppService)
    {
        _whatsAppService = whatsAppService;
    }

    [HttpPost]
    public async Task<IActionResult> SendNotification([FromBody] NotificationRequest request)
    {
        var result = await _whatsAppService.SendMessageAsync(request.PhoneNumber, request.Message);
        if (result)
        {
            return Ok("Notification sent successfully.");
        }
        return StatusCode(500, "Failed to send notification.");
    }
}

public class NotificationRequest
{
    public string PhoneNumber { get; set; }
    public string Message { get; set; }
}

This controller defines a POST endpoint that accepts a notification request containing a phone number and message. It uses the WhatsAppService to send the message and return an appropriate response.

Running and Testing Your API

With everything set up, it's time to run and test your API. Use the following command to start your application:

dotnet run

Once the application is running, you can test the API using a tool like Postman. Send a POST request to https://localhost:5001/notifications with a JSON body containing the PhoneNumber and Message fields. Here's an example request body:

{
    "PhoneNumber": "1234567890",
    "Message": "Hello, this is a test notification from WhatsApp!"
}

If everything is configured correctly, you should receive a response indicating that the notification was sent successfully.

Conclusion

Integrating WhatsApp API with a .NET Core application provides a powerful way to enhance communication capabilities, enabling real-time notifications and interactive messaging. By following the steps outlined in this article, you can set up a robust API integration, leveraging the convenience and ubiquity of WhatsApp to engage your users effectively. Whether you're sending alerts, reminders, or promotional messages, this integration ensures that your messages reach users promptly and efficiently, fostering better engagement and satisfaction.