Cheap Windows Hosting Review

Push Notification Integration between WhatsApp and the.NET Core API

Posted on by Pablo Francesco

Instantaneous contacts across the globe are made possible by the transcendence of traditional limits in communication in the digital age. One of the most widely used messaging services, WhatsApp, provides developers with a strong API so they can include its messaging features into their apps. With the use of interactive messaging services and automated notifications, this connection can greatly increase user engagement. This post will discuss how to develop push notification functionality by integrating a.NET Core API with the WhatsApp API.

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:

  1. 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.
  2. 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:

  1. 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.
  2. 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.
  3. 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.

Best ASP.NET 9.0 Core Hosting

The feature and reliability are the most important things when choosing a good ASP.NET Core hosting. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core , their servers are optimized for PHP web applications such as the latest ASP.NET Core version. The performance and the uptime of the ASP.NET Core  hosting service are excellent, and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. At HostForLIFEASP.NET, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its data centers are equipped with top equipment like cooling system, fire detection, high-speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core . And the engineers do regular maintenance and monitoring works to assure its ASP.NET Core  hosting are security and always up.
hostforlifebanner