> ## Documentation Index
> Fetch the complete documentation index at: https://plivo.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Delivery Reports

> Track SMS delivery status with message delivery report callbacks

> [tab] Node
>
> ## Overview
>
> This guide shows how to receive delivery reports for your SMS messages using Plivo's APIs and Node.js. Delivery reports are webhooks Plivo sends to your application to notify you of the status of inbound or outbound messages.
>
> ***
>
> ### How it works
>
> * **Outbound Messages**: When you send an SMS using Plivo's API, you can include a `url` parameter. Plivo will send a POST request to this URL with the status of the message (`sent`, `delivered`, `failed`, etc.).
> * **Inbound Messages**: When you receive an SMS on a Plivo number, Plivo sends the message details to the `Message URL` configured on your Plivo Application.
>
> In both cases, your application should be set up to receive these POST requests, log the data, and return a `200 OK` response to acknowledge receipt.
>
> ***
>
> ### Prerequisites
>
> * A Plivo account — [**sign up for free**](https://cx.plivo.com/signup).
> * An SMS-enabled Plivo phone number. You can [**rent a number**](https://plivo.com/docs/numbers.md).
> * Node.js and ngrok.
>
> ***
>
> ### Create a server to receive delivery reports
>
> Create a file named `delivery_reports.js` and paste this code into it. This Express server has a single endpoint that logs the body of incoming POST requests to the console.
>
> ```js theme={null}
> const express = require('express');
> const bodyParser = require('body-parser');
> const app = express();
>
> app.use(bodyParser.urlencoded({ extended: true }));
> app.set('port', (process.env.PORT || 5000));
>
> app.all('/delivery_report/', (request, response) => {
>     console.log("Delivery Report Received:");
>     console.log(request.body);
>     response.status(204).send(); // Acknowledge receipt
> });
>
> app.listen(app.get('port'), () => {
>     console.log('Node app is running on port', app.get('port'));
> });
> ```
>
> ***
>
> ### Test
>
> 1. Run your server: `node delivery_reports.js`.
> 2. Expose your local server to the internet using ngrok: `ngrok http 5000`.
>
> **For Outbound Reports:**
>
> * Use the following script to send a message. Replace the placeholders and use your ngrok URL for the `url` parameter.
>
>   ```js theme={null}
>   const plivo = require('plivo');
>   const client = new plivo.Client("<auth_id>", "<auth_token>");
>
>   client.messages.create({
>       src: "<sender_id>",
>       dst: "<destination_number>",
>       text: "Hello, this is a test for delivery reports!",
>       url: "https://<your-ngrok-url>.ngrok.io/delivery_report/"
>   }).then(response => console.log(response));
>   ```
> * Check your terminal. You should see the delivery status updates logged by your server.
>
> **For Inbound Reports:**
>
> * Create a Plivo Application with the `Message URL` set to `https://<your-ngrok-url>.ngrok.io/delivery_report/`.
> * Assign a Plivo number to the application.
> * Send an SMS to your Plivo number. The message details will appear in your terminal.

> [tab] Ruby
>
> ## Overview
>
> This guide shows how to receive delivery reports for your SMS messages using Plivo's APIs and Ruby on Rails. Delivery reports are webhooks Plivo sends to your application to notify you of the status of inbound or outbound messages.
>
> ***
>
> ### How it works
>
> * **Outbound Messages**: When you send an SMS, include a `url` parameter. Plivo will POST the delivery status to this URL.
> * **Inbound Messages**: When you receive an SMS, Plivo sends the message details to your `Message URL`.
>
> Your Rails application needs a route and controller action to receive these POST requests, log the data, and return a `200 OK` response.
>
> ***
>
> ### Prerequisites
>
> * A Plivo account — [**sign up for free**](https://cx.plivo.com/signup).
> * An SMS-enabled Plivo phone number. You can [**rent a number**](https://plivo.com/docs/numbers.md).
> * Ruby on Rails and ngrok.
>
> ***
>
> ### Create a controller to receive delivery reports
>
> In your controller (e.g., `app/controllers/plivo_controller.rb`), add this action. It will log all parameters from the incoming webhook.
>
> ```rb theme={null}
> class PlivoController < ApplicationController
>   skip_before_action :verify_authenticity_token
>
>   def delivery_report
>     puts "Delivery Report Received:"
>     puts params.inspect
>     head :ok # Acknowledge receipt with 200 OK
>   end
> end
> ```
>
> In `config/routes.rb`, add a route for this action:
>
> ```ruby theme={null}
> Rails.application.routes.draw do
>   post 'plivo/delivery_report' => 'plivo#delivery_report'
> end
> ```
>
> ***
>
> ### Test
>
> 1. Run your server: `rails server`.
> 2. Expose your server to the internet using ngrok: `ngrok http 3000`.
>
> **For Outbound Reports:**
>
> * Use the following script to send a message. Replace the placeholders and use your ngrok URL.
>
>   ```rb theme={null}
>   require "plivo"
>   include Plivo
>
>   api = RestClient.new("<auth_id>", "<auth_token>")
>   response = api.messages.create(
>       src: "<sender_id>",
>       dst: "<destination_number>",
>       text: "Hello from Ruby!",
>       url: "https://<your-ngrok-url>.ngrok.io/plivo/delivery_report",
>   )
>   puts response
>   ```
> * Check your terminal for the delivery status logs.
>
> **For Inbound Reports:**
>
> * Create a Plivo Application with the `Message URL` set to `https://<your-ngrok-url>.ngrok.io/plivo/delivery_report`.
> * Assign a Plivo number to it.
> * Send an SMS to your Plivo number and check your terminal for the message details.

> [tab] Python
>
> ## Overview
>
> This guide shows how to receive delivery reports for your SMS messages using Plivo's APIs and Python with Flask. Delivery reports are webhooks Plivo sends to your application to notify you of the status of inbound or outbound messages.
>
> ***
>
> ### How it works
>
> * **Outbound Messages**: When you send an SMS, include a `url` parameter. Plivo will POST the delivery status to this URL.
> * **Inbound Messages**: When you receive an SMS, Plivo sends the message details to your `Message URL`.
>
> Your Flask application needs an endpoint to receive these POST requests, log the data, and return a `200 OK` response.
>
> ***
>
> ### Prerequisites
>
> * A Plivo account — [**sign up for free**](https://cx.plivo.com/signup).
> * An SMS-enabled Plivo phone number. You can [**rent a number**](https://plivo.com/docs/numbers.md).
> * Python and ngrok.
>
> ***
>
> ### Create a server to receive delivery reports
>
> Create a file named `delivery_reports.py` and paste this code into it.
>
> ```py theme={null}
> from flask import Flask, request
>
> app = Flask(__name__)
>
> @app.route('/delivery_report/', methods=['POST'])
> def delivery_report():
>     print("Delivery Report Received:")
>     print(request.form.to_dict())
>     return ('Report Received', 200)
>
> if __name__ == '__main__':
>     app.run(host='0.0.0.0', debug=True)
> ```
>
> ***
>
> ### Test
>
> 1. Run your server: `python delivery_reports.py`.
> 2. Expose your server to the internet using ngrok: `ngrok http 5000`.
>
> **For Outbound Reports:**
>
> * Use this script to send a message. Replace placeholders and use your ngrok URL.
>
>   ```py theme={null}
>   import plivo
>   client = plivo.RestClient('<auth_id>', '<auth_token>')
>   response = client.messages.create(
>       src='<sender_id>',
>       dst='<destination_number>',
>       text='Hello from Python!',
>       url='https://<your-ngrok-url>.ngrok.io/delivery_report/',
>   )
>   print(response)
>   ```
> * Check your terminal for delivery status logs.
>
> **For Inbound Reports:**
>
> * Create a Plivo Application with the `Message URL` set to `https://<your-ngrok-url>.ngrok.io/delivery_report/`.
> * Assign a Plivo number to it.
> * Send an SMS to your Plivo number and check your terminal for the message details.

> [tab] PHP
>
> ## Overview
>
> This guide shows how to receive delivery reports for your SMS messages using Plivo's APIs and PHP. Delivery reports are webhooks Plivo sends to your application to notify you of the status of inbound or outbound messages.
>
> ***
>
> ### How it works
>
> * **Outbound Messages**: When you send an SMS, include a `url` parameter. Plivo will POST the delivery status to this URL.
> * **Inbound Messages**: When you receive an SMS, Plivo sends the message details to your `Message URL`.
>
> Your PHP application needs a script to receive these POST requests, log the data, and return a `200 OK` response.
>
> ***
>
> ### Prerequisites
>
> * A Plivo account — [**sign up for free**](https://cx.plivo.com/signup).
> * An SMS-enabled Plivo phone number. You can [**rent a number**](https://plivo.com/docs/numbers.md).
> * PHP, Composer, and ngrok.
>
> ***
>
> ### Create a script to receive delivery reports
>
> Create a file named `delivery_report.php` and paste this code into it.
>
> ```php theme={null}
> <?php
> // Log all POST data to a file
> $post_data = file_get_contents('php://input');
> $log_file = 'delivery_reports.log';
> file_put_contents($log_file, "--- Delivery Report ---\n", FILE_APPEND);
> file_put_contents($log_file, $post_data . "\n\n", FILE_APPEND);
>
> // Acknowledge the webhook
> http_response_code(204);
> ?>
> ```
>
> ***
>
> ### Test
>
> 1. Start your PHP server in the directory with your file.
> 2. Expose your server to the internet using ngrok.
>
> **For Outbound Reports:**
>
> * Use this script to send a message. Replace placeholders and use your ngrok URL.
>
>   ```php theme={null}
>   <?php
>   require 'vendor/autoload.php';
>   use Plivo\RestClient;
>   $client = new RestClient("<auth_id>", "<auth_token>");
>   $response = $client->messages->create([
>       "src" => "<sender_id>",
>       "dst" => "<destination_number>",
>       "text" => "Hello from PHP!",
>       "url" => "https://<your-ngrok-url>.ngrok.io/delivery_report.php"
>   ]);
>   print_r($response);
>   ?>
>   ```
> * Check the `delivery_reports.log` file for status updates.
>
> **For Inbound Reports:**
>
> * Create a Plivo Application with the `Message URL` set to `https://<your-ngrok-url>.ngrok.io/delivery_report.php`.
> * Assign a Plivo number to it.
> * Send an SMS to your Plivo number and check the log file.

> [tab] .NET
>
> ## Overview
>
> This guide shows how to receive delivery reports for your SMS messages using Plivo's APIs and .NET. Delivery reports are webhooks Plivo sends to your application to notify you of the status of inbound or outbound messages.
>
> ***
>
> ### How it works
>
> * **Outbound Messages**: When you send an SMS, include a `url` parameter. Plivo will POST the delivery status to this URL.
> * **Inbound Messages**: When you receive an SMS, Plivo sends the message details to your `Message URL`.
>
> Your .NET application needs a controller action to receive these POST requests, log the data, and return a `200 OK` response.
>
> ***
>
> ### Prerequisites
>
> * A Plivo account — [**sign up for free**](https://cx.plivo.com/signup).
> * An SMS-enabled Plivo phone number. You can [**rent a number**](https://plivo.com/docs/numbers.md).
> * .NET and ngrok.
>
> ***
>
> ### Create a controller to receive delivery reports
>
> In your controller (e.g., `DeliveryReportController.cs`), add this action. It will log all form fields from the incoming webhook.
>
> ```csharp theme={null}
> using System;
> using Microsoft.AspNetCore.Mvc;
>
> namespace Demo.Controllers
> {
>     public class DeliveryReport : Controller
>     {
>         [HttpPost]
>         public IActionResult Index()
>         {
>             Console.WriteLine("--- Delivery Report Received ---");
>             foreach (var key in Request.Form.Keys)
>             {
>                 Console.WriteLine($"{key}: {Request.Form[key]}");
>             }
>             return Ok("Report Received");
>         }
>     }
> }
> ```
>
> ***
>
> ### Test
>
> 1. Run your project.
> 2. Expose your server to the internet using ngrok.
>
> **For Outbound Reports:**
>
> * Use this code to send a message. Replace placeholders and use your ngrok URL.
>
>   ```csharp theme={null}
>   var api = new PlivoApi("<auth_id>", "<auth_token>");
>   var response = api.Message.Create(
>       src: "<sender_id>",
>       dst: new List<string> { "<destination_number>" },
>       text: "Hello from .NET!",
>       url: "https://<your-ngrok-url>.ngrok.io/DeliveryReport"
>   );
>   Console.WriteLine(response);
>   ```
> * Check your console for delivery status logs.
>
> **For Inbound Reports:**
>
> * Create a Plivo Application with the `Message URL` set to `https://<your-ngrok-url>.ngrok.io/DeliveryReport`.
> * Assign a Plivo number to it.
> * Send an SMS to your Plivo number and check your console.

> [tab] Java
>
> ## Overview
>
> This guide shows how to receive delivery reports for your SMS messages using Plivo's APIs and Java with Spring. Delivery reports are webhooks Plivo sends to your application to notify you of the status of inbound or outbound messages.
>
> ***
>
> ### How it works
>
> * **Outbound Messages**: When you send an SMS, include a `url` parameter. Plivo will POST the delivery status to this URL.
> * **Inbound Messages**: When you receive an SMS, Plivo sends the message details to your `Message URL`.
>
> Your Spring application needs an endpoint to receive these POST requests, log the data, and return a `200 OK` response.
>
> ***
>
> ### Prerequisites
>
> * A Plivo account — [**sign up for free**](https://cx.plivo.com/signup).
> * An SMS-enabled Plivo phone number. You can [**rent a number**](https://plivo.com/docs/numbers.md).
> * Java and ngrok.
>
> ***
>
> ### Create a controller to receive delivery reports
>
> In your main application file, paste this code.
>
> ```java theme={null}
> package com.example.demo;
>
> import org.springframework.boot.SpringApplication;
> import org.springframework.boot.autoconfigure.SpringBootApplication;
> import org.springframework.http.ResponseEntity;
> import org.springframework.util.MultiValueMap;
> import org.springframework.web.bind.annotation.PostMapping;
> import org.springframework.web.bind.annotation.RequestBody;
> import org.springframework.web.bind.annotation.RestController;
>
> @RestController
> @SpringBootApplication
> public class DemoApplication {
>
>     public static void main(String[] args) {
>         SpringApplication.run(DemoApplication.class, args);
>     }
>
>     @PostMapping(value = "/delivery_report/")
>     public ResponseEntity<String> deliveryReport(@RequestBody MultiValueMap<String, String> body) {
>         System.out.println("--- Delivery Report Received ---");
>         System.out.println(body);
>         return ResponseEntity.ok("Report Received");
>     }
> }
> ```
>
> ***
>
> ### Test
>
> 1. Run your application.
> 2. Expose your server to the internet using ngrok.
>
> **For Outbound Reports:**
>
> * Use this code to send a message. Replace placeholders and use your ngrok URL.
>
>   ```java theme={null}
>   Plivo.init("<auth_id>", "<auth_token>");
>   Message.creator(
>           "<sender_id>",
>           "<destination_number>",
>           "Hello from Java!"
>       )
>       .url("https://<your-ngrok-url>.ngrok.io/delivery_report/")
>       .create();
>   ```
> * Check your console for delivery status logs.
>
> **For Inbound Reports:**
>
> * Create a Plivo Application with the `Message URL` set to `https://<your-ngrok-url>.ngrok.io/delivery_report/`.
> * Assign a Plivo number to it.
> * Send an SMS to your Plivo number and check your console.

> [tab] Go
>
> ## Overview
>
> This guide shows how to receive delivery reports for your SMS messages using Plivo's APIs and Go. Delivery reports are webhooks Plivo sends to your application to notify you of the status of inbound or outbound messages.
>
> ***
>
> ### How it works
>
> * **Outbound Messages**: When you send an SMS, include a `url` parameter. Plivo will POST the delivery status to this URL.
> * **Inbound Messages**: When you receive an SMS, Plivo sends the message details to your `Message URL`.
>
> Your Go application needs an HTTP handler to receive these POST requests, log the data, and return a `200 OK` response.
>
> ***
>
> ### Prerequisites
>
> * A Plivo account — [**sign up for free**](https://cx.plivo.com/signup).
> * An SMS-enabled Plivo phone number. You can [**rent a number**](https://plivo.com/docs/numbers.md).
> * Go and ngrok.
>
> ***
>
> ### Create a server to receive delivery reports
>
> Create a file named `delivery_report.go` and paste this code into it.
>
> ```go theme={null}
> package main
>
> import (
>     "fmt"
>     "net/http"
> )
>
> func deliveryReport(w http.ResponseWriter, r *http.Request) {
>     r.ParseForm()
>     fmt.Println("--- Delivery Report Received ---")
>     for key, values := range r.Form {
>         fmt.Printf("%s: %s\n", key, values[0])
>     }
>     w.WriteHeader(http.StatusNoContent) // Acknowledge receipt
> }
>
> func main() {
>     http.HandleFunc("/delivery_report/", deliveryReport)
>     http.ListenAndServe(":8080", nil)
> }
> ```
>
> ***
>
> ### Test
>
> 1. Run your server: `go run delivery_report.go`.
> 2. Expose your server to the internet using ngrok: `ngrok http 8080`.
>
> **For Outbound Reports:**
>
> * Use this code to send a message. Replace placeholders and use your ngrok URL.
>
>   ```go theme={null}
>   client, _ := plivo.NewClient("<auth_id>", "<auth_token>", &plivo.ClientOptions{})
>   client.Messages.Create(
>       plivo.MessageCreateParams{
>           Src:  "<sender_id>",
>           Dst:  "<destination_number>",
>           Text: "Hello from Go!",
>           URL:  "https://<your-ngrok-url>.ngrok.io/delivery_report/",
>       },
>   )
>   ```
> * Check your terminal for delivery status logs.
>
> **For Inbound Reports:**
>
> * Create a Plivo Application with the `Message URL` set to `https://<your-ngrok-url>.ngrok.io/delivery_report/`.
> * Assign a Plivo number to it.
> * Send an SMS to your Plivo number and check your terminal.