> ## 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.

# Get Started with Node.js

> Send your first SMS using Node.js and Express with Plivo APIs

<Tabs>
  <Tab title="Node.js & Express">
    # Get Started with Node.js Using Express

    ## Sign up for a Plivo account

    When you [sign up with Plivo](https://cx.plivo.com/signup), we give you a free trial account and free credits to experiment with and learn about our services. You can [add a number](https://cx.plivo.com/phone-numbers) to your account to start testing the full range of our voice and SMS service features.

    Follow these steps to get a free trial account:

    1. [Sign up](https://cx.plivo.com/signup) with your work email address.
    2. Check your inbox for an activation email message from Plivo. Click on the link in the message to activate your account.
    3. Enter your mobile number to complete the phone verification step.

    ### Sign up with your work email address

    <Frame>
      <img src="https://mintcdn.com/plivo/Ac6PoKJHHxDx1U63/images/signup.png?fit=max&auto=format&n=Ac6PoKJHHxDx1U63&q=85&s=56190e6fffc6ae0c70dba8c7c69f435b" width="1440" height="900" data-path="images/signup.png" />
    </Frame>

    If you have any issues creating a Plivo account, please contact our [support team](https://support.plivo.com/hc/en-us/) for assistance.

    To get started, try sending an SMS message either by using our API and XML documents, or via {/* [PHLO](/phlo/getting-started/getting-started) */}, our visual design tool, which allows you to create message flows using an intuitive canvas and deploy them with few clicks.

    <Tabs>
      <Tab title="Using API">
        ## Install Node.js, Express, and the Plivo Node.js SDK

        You must set up and install Node.js, Express, and Plivo’s Node SDK before you send your first SMS message.

        ### Install Node.js

        You can check whether you have Node.js installed under macOS or Linux by running the command `node --version` in a terminal window. Under Windows, open a Windows command prompt or PowerShell and type `node -v`. If you don’t have Node.js installed or want a more current version, <a href="https://nodejs.org/en/download/">download and install it</a>.

        ### Install Express and the Plivo Node.js SDK

        Create a projects directory and change into it.

        ```shell theme={null}
        $ mkdir mynodeapp
        $ cd mynodeapp
        ```

        Install Express and the Plivo Node.js SDK using [npm](https://www.npmjs.com/package/plivo).

        ```shell theme={null}
        $ npm install express plivo
        ```

        Once you’ve set up your development environment, you can start sending and receiving messages using our APIs and XML documents. Here are three common use cases to get you started.

        ## Send your first outbound SMS/MMS message

        You must have a Plivo phone number to send messages to the US or Canada; you can rent a Plivo number from Phone Numbers > [Buy Numbers](https://cx.plivo.com/phone-numbers) on the Plivo console or via the [Numbers API](/numbers/api/phone-number/#buy-a-phone-number).

        ### Create an Express server

        Create a file called `SendSMS.js` and paste into it this code.

        <Tabs>
          <Tab title="SMS">
            ```js theme={null}
            const express = require('express');
            const bodyParser = require('body-parser');
            const app = express();

            app.use(bodyParser.urlencoded({
                extended: true
            }));
            app.use(function(req, response, next) {
                response.contentType('application/xml');
                next();
            });
            app.set('port', (process.env.PORT || 3000));
            app.all('/outbound_sms/', function(request, response) {
                let client = new plivo.Client('<auth_id>', '<auth_token>');
                client.messages.create({
                        src: '<sender_id>',
                        dst: '<destination_number>',
                        text: 'Hello, from Node Express!'
                    }

                ).then(function(message_created) {
                    console.log(message_created)
                });
            });
            app.listen(app.get('port'), function() {
                console.log('Node app is running on port', app.get('port'));
            });
            ```
          </Tab>

          <Tab title="MMS">
            ```js theme={null}
            const express = require('express');
            const bodyParser = require('body-parser');
            const app = express();

            app.use(bodyParser.urlencoded({
                extended: true
            }));
            app.use(function(req, response, next) {
                response.contentType('application/xml');
                next();
            });
            app.set('port', (process.env.PORT || 3000));
            app.all('/outbound_mms/', function(request, response) {
                let client = new plivo.Client('<auth_id>', '<auth_token>');
                response = client.messages.create({
                    src: '<sender_id>',
                    dst: '<destination_number>',
                    text: 'Hello, MMS from Express!',
                    type: 'mms',
                    media_urls: ['https://media.giphy.com/media/26gscSULUcfKU7dHq/source.gif'],
                    media_ids: ['801c2056-33ab-499c-80ef-58b574a462a2']
                }).then(function(response) {
                    console.log(response)
                });
            });
            app.listen(app.get('port'), function() {
                console.log('Node app is running on port', app.get('port'));
            });
            ```
          </Tab>
        </Tabs>

        Replace the auth placeholders with your authentication credentials from the [Plivo console](https://cx.plivo.com/home). Replace the phone number placeholders with actual phone numbers in [E.164 format](https://en.wikipedia.org/wiki/E.164) (for example, +12025551234). In countries other than the US and Canada you can use a [sender ID](/messaging/concepts/sender-id-usage/) for the message source.

        <Note>
          **Note:** We recommend that you store your credentials in the `auth_id` and `auth_token` environment variables to avoid the possibility of accidentally committing them to source control. If you do this, you can initialize the client with no arguments and Plivo will automatically fetch the values from the environment variables. You can use `process.env` to store environment variables and fetch them when initializing the client.
        </Note>

        ### Test

        Save the file and run it.

        ```shell theme={null}
        $ node SendSMS.js
        ```

        ## Receive your first inbound SMS/MMS message

        To receive incoming messages, you must have a Plivo phone number that supports SMS; you can rent numbers from the [Numbers](https://cx.plivo.com/phone-numbers) page of the Plivo console or by using the [Numbers API](/numbers/).

        ### Create an Express server

        Create a file called `receive_sms.js` and paste into it this code.

        <Tabs>
          <Tab title="SMS">
            ```js theme={null}
            const express = require('express');
            const bodyParser = require('body-parser');
            const app = express();

            app.use(bodyParser.urlencoded({
                extended: true
            }));
            app.use(function (req, response, next) {
                response.contentType('application/xml');
                next();
            });
            app.set('port', (process.env.PORT || 3000));
            app.all('/receive_sms/', function (request, response) {
                let from_number = request.body.From || request.query.From;
                let to_number = request.body.To || request.query.To;
                let text = request.body.Text || request.query.Text;
                console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text);
            });
            app.listen(app.get('port'), function () {
                console.log('Node app is running on port', app.get('port'));
            });
            ```
          </Tab>

          <Tab title="MMS">
            ```js theme={null}
            const express = require('express');
            const bodyParser = require('body-parser');
            const app = express();

            app.use(bodyParser.urlencoded({
                extended: true
            }));
            app.use(function (req, response, next) {
                response.contentType('application/xml');
                next();
            });
            app.set('port', (process.env.PORT || 3000));
            app.all('/receive_sms/', function (request, response) {
                let from_number = request.body.From || request.query.From;
                let to_number = request.body.To || request.query.To;
                let text = request.body.Text || request.query.Text;
                let media_url = request.body.Media0 || request.query.Media0;
                console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text+ ', Media: ' + media_url);
            });
            app.listen(app.get('port'), function () {
                console.log('Node app is running on port', app.get('port'));
            });
            ```
          </Tab>
        </Tabs>

        Save the file and run it.

        ```shell theme={null}
        $ node receive_sms.js
        ```

        You should see your basic server application in action at /receive\_sms/.

        ### Expose your local server to the internet

        To receive incoming messages, your local server must connect with Plivo API services. For that, we recommend using [ngrok](https://ngrok.com/download), which exposes local servers running behind NATs and firewalls to the public internet over secure tunnels. Using ngrok, you can set webhooks that can talk to the Plivo server.

        <Frame>
          <img src="https://mintcdn.com/plivo/M2NzHE_bNZbCm0gd/images/ngrok-diagram.png?fit=max&auto=format&n=M2NzHE_bNZbCm0gd&q=85&s=b2ef4b4d52c133d126fd0d4303c33a61" alt="ngrok block diagram" width="1626" height="601" data-path="images/ngrok-diagram.png" />
        </Frame>

        Install ngrok and run it on the command line, specifying the port that  hosts the application on which you want to receive messages (80 in this case):

        ```shell theme={null}
        $ ./ngrok http 80
        ```

        This starts the ngrok server on your local server. Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

        <Frame>
          <img src="https://mintcdn.com/plivo/M2NzHE_bNZbCm0gd/images/ngrok.png?fit=max&auto=format&n=M2NzHE_bNZbCm0gd&q=85&s=ce35ccb7eebdb2af565a2a3a2cf2be18" alt="Sample ngrok CLI" width="786" height="238" data-path="images/ngrok.png" />
        </Frame>

        Now people can send messages to your Plivo number.

        ### Create a Plivo application to receive messages

        Associate the controller you created with Plivo by creating a Plivo application. Visiting Messaging > [Applications](https://cx.plivo.com/xml-applications) and click **Add New Application**. You can also use Plivo's [Application API](/account/api/application/#create-an-application).

        Give your application a name — we called ours `Receive SMS`. Enter the server URL you want to use (for example `https://<yourdomain>.com/receive_sms/`) in the `Message URL` field and set the method to `POST`. Click **Create Application** to save your application.

        <Frame>
          <img src="https://mintcdn.com/plivo/2OFvQXVNT3srKLUy/images/create_SMS_app.jpg?fit=max&auto=format&n=2OFvQXVNT3srKLUy&q=85&s=665006f2112a8e6113716029adfbf2a7" alt="Create Application" width="1440" height="785" data-path="images/create_SMS_app.jpg" />
        </Frame>

        ### Assign a Plivo number to your application

        Navigate to the [Numbers](https://cx.plivo.com/phone-numbers) page and select the phone number you want to use for this application.

        From the Application Type drop-down, select `XML Application`.

        From the Plivo Application drop-down, select `Receive SMS` (the name we gave the application).

        Click **Update Number** to save.

        <Frame>
          <img src="https://mintcdn.com/plivo/NFI9_HRHTMInDf93/images/assign_SMS_app.jpg?fit=max&auto=format&n=NFI9_HRHTMInDf93&q=85&s=94324dc41c7e8ade7a60c98e5fe20094" alt="Assign Phone Number to Receive SMS App" width="1440" height="785" data-path="images/assign_SMS_app.jpg" />
        </Frame>

        ### Test

        Send a text message to the Plivo number you specified using any phone.

        ## Reply to an incoming SMS/MMS message

        To receive incoming messages, you must have a Plivo phone number that supports SMS; you can rent numbers from the [Numbers](https://cx.plivo.com/phone-numbers) page of the Plivo console or by using the [Numbers API](/numbers/).

        ### Create an Express server

        Create a file called `reply_to_sms.js` and paste into it this code.

        ```js theme={null}
        const plivo = require('plivo');
        const express = require('express');
        const bodyParser = require('body-parser');
        const app = express();

        app.use(bodyParser.urlencoded({
            extended: true
        }));
        app.use(function(req, response, next) {
            response.contentType('application/xml');
            next();
        });
        app.set('port', (process.env.PORT || 3000));
        app.all('/reply_sms/', function(request, response) {
            let from_number = request.body.From || request.query.From;
            let to_number = request.body.To || request.query.To;
            let text = request.body.Text || request.query.Text;
            console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text);

            //send the details to generate an XML
            let r = plivo.Response();
            let params = {
                'src': to_number,
                'dst': from_number,
            };
            let message_body = "This is an automatic response";
            r.addMessage(message_body, params);
            console.log(r.toXML());
            response.end(r.toXML());
        });
        app.listen(app.get('port'), function() {
            console.log('Node app is running on port', app.get('port'));
        });
        ```

        If you haven’t done so already, [expose your local server to the internet](/sdk/server/setting-up-dev-environment).

        ### Create a Plivo application to reply to messages

        Associate the controller you created with Plivo by creating a Plivo application. Visiting Messaging > [Applications](https://cx.plivo.com/xml-applications) and click **Add New Application**. You can also use Plivo's [Application API](/account/api/application/#create-an-application).

        Give your application a name — we called ours `Reply Incoming SMS`. Enter the server URL you want to use (for example `http://<yourdomain>.com/replysms/`) in the `Message URL` field and set the method to `POST`. Click **Create Application** to save your application.

        <Frame>
          <img src="https://mintcdn.com/plivo/2OFvQXVNT3srKLUy/images/create_reply_sms.png?fit=max&auto=format&n=2OFvQXVNT3srKLUy&q=85&s=0371a975aa748267124e9ea9debc7a0f" alt="Create Application" width="1440" height="822" data-path="images/create_reply_sms.png" />
        </Frame>

        ### Assign a Plivo number to your application

        Navigate to the [Numbers](https://cx.plivo.com/phone-numbers) page and select the phone number you want to use for this application.

        From the Application Type drop-down, select `XML Application`.

        From the Plivo Application drop-down, select `Reply Incoming SMS` (the name we gave the application).

        Click **Update Number** to save.

        ### Test

        Send a text message to the Plivo number you specified using any phone. You should receive a reply.

        ## More use cases

        We illustrate [more than a dozen use cases](/messaging/use-cases/send-an-sms) with code for both API/XML and PHLO on our documentation pages.
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="Node.js & NestJS">
    # Get Started with Node.js Using the NestJS Framework

    ## Sign up for a Plivo account

    When you [sign up with Plivo](https://cx.plivo.com/signup), we give you a free trial account and free credits to experiment with and learn about our services. You can [add a number](https://cx.plivo.com/phone-numbers) to your account to start testing the full range of our voice and SMS service features.

    Follow these steps to get a free trial account:

    1. [Sign up](https://cx.plivo.com/signup) with your work email address.
    2. Check your inbox for an activation email message from Plivo. Click on the link in the message to activate your account.
    3. Enter your mobile number to complete the phone verification step.

    ### Sign up with your work email address

    <Frame>
      <img src="https://mintcdn.com/plivo/Ac6PoKJHHxDx1U63/images/signup.png?fit=max&auto=format&n=Ac6PoKJHHxDx1U63&q=85&s=56190e6fffc6ae0c70dba8c7c69f435b" width="1440" height="900" data-path="images/signup.png" />
    </Frame>

    If you have any issues creating a Plivo account, please contact our [support team](https://support.plivo.com/hc/en-us/) for assistance.

    To get started, try sending an SMS message either by using our API and XML documents, or via {/* [PHLO](/phlo/getting-started/getting-started) */}, our visual design tool, which allows you to create message flows using an intuitive canvas and deploy them with few clicks.

    <Tabs>
      <Tab title="Using API">
        ## Install Node.js, NestJS, and the Plivo Node.js SDK

        You must set up and install Node.js, NestJS, and Plivo’s Node SDK before you send your first SMS message.

        ### Install Node.js

        You can check whether you have Node.js installed under macOS or Linux by running the command `node --version` in a terminal window. Under Windows, open a Windows command prompt or PowerShell and type `node -v`. If you don’t have Node.js installed or want a more current version, <a href="https://nodejs.org/en/download/">download and install it</a>.

        ### Install NestJS

        Install Nest CLI using [npm](https://www.npmjs.com/package/@nestjs/cli).

        ```shell theme={null}
        $ npm i @nestjs/cli
        ```

        Choose the npm package manager when prompted for which package manager to use.

        Create a new NestJS project and change to the project directory.

        ```shell theme={null}
        $ nest new plivosms
        $ cd plivosms
        ```

        ### Install the Plivo Node.js SDK

        Install the Plivo Node.js SDK using [npm](https://www.npmjs.com/package/plivo).

        ```shell theme={null}
        $ npm install plivo
        ```

        Once you’ve set up your development environment, you can start sending and receiving messages using our APIs and XML documents. Here are three common use cases to get you started.

        ## Send your first outbound SMS/MMS message

        You must have a Plivo phone number to send messages to the US or Canada; you can rent a Plivo number from Phone Numbers > [Buy Numbers](https://cx.plivo.com/phone-numbers) on the Plivo console or via the [Numbers API](/numbers/api/phone-number/#buy-a-phone-number).

        ### Create a NestJS server

        Create a file called `SendSMS.js` and paste into it this code.

        <Tabs>
          <Tab title="SMS">
            ```js theme={null}
            import {Controller,Get,Post,Res,HttpStatus} from '@nestjs/common';
            import {Response} from 'express';
            import {AppService} from './app.service';
            const plivo = require('plivo');

            @Controller()
            export class AppController {
                constructor(private readonly appService: AppService) {}

                @Get('/outbound')
                sendSMS() {
                    const client = new plivo.Client('<auth_id>', '<auth_token>');
                    client.messages.create({
                            src: '<sender_id>',
                            dst: '<destination_number>',
                            text: 'Hello, from NestJS!'
                        })
                        .then(
                            function(response) {
                                console.log(response);
                            },
                            function(err) {
                                console.error(err);
                            },
                        );
                }
            }
            ```
          </Tab>

          <Tab title="MMS">
            ```js theme={null}
            import {Controller,Get,Post,Res,HttpStatus} from '@nestjs/common';
            import {Response} from 'express';
            import {AppService} from './app.service';
            const plivo = require('plivo');

            @Controller()
            export class AppController {
                constructor(private readonly appService: AppService) {}

                @Get('/outbound')
                sendMMS() {
                    const client = new plivo.Client('<auth_id>', '<auth_token>');
                    client.messages.create(
                            {
                                src: '<sender_id>',
                                dst: '<destination_number>',
                                text: 'Hello, MMS from NestJS!',
                                type: 'mms',
                                media_urls: ['https://media.giphy.com/media/26gscSULUcfKU7dHq/source.gif'],
                                media_ids: ['801c2056-33ab-499c-80ef-58b574a462a2']
                            }
                        )
                        .then(
                            function(response) {
                                console.log(response);
                            },
                            function(err) {
                                console.error(err);
                            },
                        );
                }
            }
            ```
          </Tab>
        </Tabs>

        Replace the auth placeholders with your authentication credentials from the [Plivo console](https://cx.plivo.com/home). Replace the phone number placeholders with actual phone numbers in [E.164 format](https://en.wikipedia.org/wiki/E.164) (for example, +12025551234). In countries other than the US and Canada you can use a [sender ID](/messaging/concepts/sender-id-usage/) for the message source.

        <Note>
          **Note:** We recommend that you store your credentials in the `auth_id` and `auth_token` environment variables to avoid the possibility of accidentally committing them to source control. If you do this, you can initialize the client with no arguments and Plivo will automatically fetch the values from the environment variables. You can use `process.env` to store environment variables and fetch them when initializing the client.
        </Note>

        ### Test

        Save the file and run it.

        ```shell theme={null}
        $ npm run start
        ```

        ## Receive your first inbound SMS/MMS message

        To receive incoming messages, you must have a Plivo phone number that supports SMS; you can rent numbers from the [Numbers](https://cx.plivo.com/phone-numbers) page of the Plivo console or by using the [Numbers API](/numbers/).

        ### Create a NestJS server

        Create a file called `receive_sms.js` and paste into it this code.

        <Tabs>
          <Tab title="SMS">
            ```js theme={null}
            import { Controller, Get, Post, Res, HttpStatus } from '@nestjs/common';
            import { Response } from 'express';
            import { AppService } from './app.service';
            const plivo = require('plivo');

            @Controller()
            export class AppController {
                constructor(private readonly appService: AppService) {}

                @Get('/outbound')
                sendSMS() {
                    ..........;
                    ..........;
                }
                @Post('/receive')
                async createPosting(@Body('From') from: string, @Body('To') to: string,@Body('Text') text: string) {
                return `Filter for ${from} ${to} ${text}`;
              }
            }
            ```
          </Tab>

          <Tab title="MMS">
            ```js theme={null}
            import { Controller, Get, Post, Res, HttpStatus } from '@nestjs/common';
            import { Response } from 'express';
            import { AppService } from './app.service';
            const plivo = require('plivo');

            @Controller()
            export class AppController {
                constructor(private readonly appService: AppService) {}

                @Get('/outbound')
                sendSMS() {
                    ..........;
                    ..........;
                }
                @Post('/receive')
                async createPosting(@Body('From') from: string, @Body('To') to: string,@Body('Text') text: string,@Body('Media0') media_url: string) {
                return `Filter for ${from} ${to} ${text} ${media_url}`;
              }
            }
            ```
          </Tab>
        </Tabs>

        Save the file and run it.

        ```shell theme={null}
        $ npm run start
        ```

        You should see your basic server application in action at /receive/

        ### Expose your local server to the internet

        To receive incoming messages, your local server must connect with Plivo API services. For that, we recommend using [ngrok](https://ngrok.com/download), which exposes local servers running behind NATs and firewalls to the public internet over secure tunnels. Using ngrok, you can set webhooks that can talk to the Plivo server.

        <Frame>
          <img src="https://mintcdn.com/plivo/M2NzHE_bNZbCm0gd/images/ngrok-diagram.png?fit=max&auto=format&n=M2NzHE_bNZbCm0gd&q=85&s=b2ef4b4d52c133d126fd0d4303c33a61" alt="ngrok block diagram" width="1626" height="601" data-path="images/ngrok-diagram.png" />
        </Frame>

        Install ngrok and run it on the command line, specifying the port that  hosts the application on which you want to receive messages (80 in this case):

        ```shell theme={null}
        $ ./ngrok http 80
        ```

        This starts the ngrok server on your local server. Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

        <Frame>
          <img src="https://mintcdn.com/plivo/M2NzHE_bNZbCm0gd/images/ngrok.png?fit=max&auto=format&n=M2NzHE_bNZbCm0gd&q=85&s=ce35ccb7eebdb2af565a2a3a2cf2be18" alt="Sample ngrok CLI" width="786" height="238" data-path="images/ngrok.png" />
        </Frame>

        Now people can send messages to your Plivo number.

        ### Create a Plivo application to receive messages

        Associate the controller you created with Plivo by creating a Plivo application. Visiting Messaging > [Applications](https://cx.plivo.com/xml-applications) and click **Add New Application**. You can also use Plivo's [Application API](/account/api/application/#create-an-application).

        Give your application a name — we called ours `Receive SMS`. Enter the server URL you want to use (for example `https://<yourdomain>.com/receive_sms/`) in the `Message URL` field and set the method to `POST`. Click **Create Application** to save your application.

        <Frame>
          <img src="https://mintcdn.com/plivo/2OFvQXVNT3srKLUy/images/create_SMS_app.jpg?fit=max&auto=format&n=2OFvQXVNT3srKLUy&q=85&s=665006f2112a8e6113716029adfbf2a7" alt="Create Application" width="1440" height="785" data-path="images/create_SMS_app.jpg" />
        </Frame>

        ### Assign a Plivo number to your application

        Navigate to the [Numbers](https://cx.plivo.com/phone-numbers) page and select the phone number you want to use for this application.

        From the Application Type drop-down, select `XML Application`.

        From the Plivo Application drop-down, select `Receive SMS` (the name we gave the application).

        Click **Update Number** to save.

        <Frame>
          <img src="https://mintcdn.com/plivo/NFI9_HRHTMInDf93/images/assign_SMS_app.jpg?fit=max&auto=format&n=NFI9_HRHTMInDf93&q=85&s=94324dc41c7e8ade7a60c98e5fe20094" alt="Assign Phone Number to Receive SMS App" width="1440" height="785" data-path="images/assign_SMS_app.jpg" />
        </Frame>

        ### Test

        Send a text message to the Plivo number you specified using any phone.

        ## Reply to an incoming SMS/MMS message

        To receive incoming messages, you must have a Plivo phone number that supports SMS; you can rent numbers from the [Numbers](https://cx.plivo.com/phone-numbers) page of the Plivo console or by using the [Numbers API](/numbers/).

        ### Create a NestJS server

        Create a file called `reply_sms.js` and paste into it this code.

        ```js theme={null}
        import {Controller,Get,Post,Res,HttpStatus} from '@nestjs/common';
        import {Response} from 'express';
        import {AppService} from './app.service';
        const plivo = require('plivo');

        @Controller()
        export class AppController {
            constructor(private readonly appService: AppService) {}

            @Get('/outbound')
            sendSMS() {
                ..........;
                ..........;
            }
            @Get('/inbound')
            xmlResponse(@Res() res: Response) {
                ..........;
                ..........;
            }
            
            // Reply to incoming messages.
            @Post('/receive')
            async createPosting(@Body('From') from: string, @Body('To') to: string, @Body('Text') text: string) {
                console.log('Message received - From: ' + from + ', To: ' + to + ', Text: ' + text);
                var message_body = "This is an automatic response";
                r.addMessage(message_body, params);
                console.log(r.toXML()); //Prints the XML
                res.set('Content-Type', 'text/xml');
                res.send(r.toXML());
            }

        }
        ```

        If you haven’t done so already, [expose your local server to the internet](/sdk/server/setting-up-dev-environment).

        ### Create a Plivo application to reply to messages

        Associate the controller you created with Plivo by creating a Plivo application. Visiting Messaging > [Applications](https://cx.plivo.com/xml-applications) and click **Add New Application**. You can also use Plivo's [Application API](/account/api/application/#create-an-application).

        Give your application a name — we called ours `Reply Incoming SMS`. Enter the server URL you want to use (for example `http://<yourdomain>.com/replysms/`) in the `Message URL` field and set the method to `POST`. Click **Create Application** to save your application.

        <Frame>
          <img src="https://mintcdn.com/plivo/2OFvQXVNT3srKLUy/images/create_reply_sms.png?fit=max&auto=format&n=2OFvQXVNT3srKLUy&q=85&s=0371a975aa748267124e9ea9debc7a0f" alt="Create Application" width="1440" height="822" data-path="images/create_reply_sms.png" />
        </Frame>

        ### Assign a Plivo number to your application

        Navigate to the [Numbers](https://cx.plivo.com/phone-numbers) page and select the phone number you want to use for this application.

        From the Application Type drop-down, select `XML Application`.

        From the Plivo Application drop-down, select `Reply Incoming SMS` (the name we gave the application).

        Click **Update Number** to save.

        ### Test

        Send a text message to the Plivo number you specified using any phone. You should receive a reply.

        ## More use cases

        We illustrate [more than a dozen use cases](/messaging/use-cases/send-an-sms) with code for both API/XML and PHLO on our documentation pages.
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="Node.js & Sails">
    # Get Started with Node.js Using the Sails Framework

    ## Sign up for a Plivo account

    When you [sign up with Plivo](https://cx.plivo.com/signup), we give you a free trial account and free credits to experiment with and learn about our services. You can [add a number](https://cx.plivo.com/phone-numbers) to your account to start testing the full range of our voice and SMS service features.

    Follow these steps to get a free trial account:

    1. [Sign up](https://cx.plivo.com/signup) with your work email address.
    2. Check your inbox for an activation email message from Plivo. Click on the link in the message to activate your account.
    3. Enter your mobile number to complete the phone verification step.

    ### Sign up with your work email address

    <Frame>
      <img src="https://mintcdn.com/plivo/Ac6PoKJHHxDx1U63/images/signup.png?fit=max&auto=format&n=Ac6PoKJHHxDx1U63&q=85&s=56190e6fffc6ae0c70dba8c7c69f435b" width="1440" height="900" data-path="images/signup.png" />
    </Frame>

    If you have any issues creating a Plivo account, please contact our [support team](https://support.plivo.com/hc/en-us/) for assistance.

    To get started, try sending an SMS message either by using our API and XML documents, or via {/* [PHLO](/phlo/getting-started/getting-started) */}, our visual design tool, which allows you to create message flows using an intuitive canvas and deploy them with few clicks.

    <Tabs>
      <Tab title="Using API">
        ## Install Node.js, Sails, and the Plivo Node.js SDK

        You must set up and install Node.js, Sails, and Plivo’s Node SDK before you send your first SMS message.

        ### Install Node.js

        You can check whether you have Node.js installed under macOS or Linux by running the command `node --version` in a terminal window. Under Windows, open a Windows command prompt or PowerShell and type `node -v`. If you don’t have Node.js installed or want a more current version, <a href="https://nodejs.org/en/download/">download and install it</a>.

        ### Install Sails

        Install Sails using [npm](https://www.npmjs.com/package/sails).

        ```shell theme={null}
        $ npm install sails -g
        ```

        Choose the npm package manager when prompted for which package manager to use.

        Create a new (empty) Sails project and change to the project directory.

        ```shell theme={null}
        $ sails new <app_name> 
        $ cd <app_name>
        ```

        ### Install the Plivo Node.js SDK

        Install the Plivo Node.js SDK using [npm](https://www.npmjs.com/package/plivo).

        ```shell theme={null}
        $ npm install plivo
        ```

        Once you’ve set up your development environment, you can start sending and receiving messages using our APIs and XML documents. Here are three common use cases to get you started.

        ## Send your first outbound SMS/MMS message

        You must have a Plivo phone number to send messages to the US or Canada; you can rent a Plivo number from Phone Numbers > [Buy Numbers](https://cx.plivo.com/phone-numbers) on the Plivo console or via the [Numbers API](/numbers/api/phone-number/#buy-a-phone-number).

        ### Create a Sails controller

        Create a new controller called “hello.”

        ```shell theme={null}
        $ sails generate controller hello
        ```

        Edit api/controllers/HelloController.js and paste into it this code.

        <Tabs>
          <Tab title="SMS">
            ```js theme={null}
            var plivo = require('plivo');

             module.exports = {
                 send_sms: function(req, res) {
                     var client = new plivo.Client("<auth_id>", "<auth_token>");
                     client.messages.create({
                         src: "<from_number>",
                         dst: "<to_number>",
                         text: "Hello, this is from Sails"
                     }).then(function(response) {
                         return res.status(200).json(response);
                     });
                 }, 
             };
            ```
          </Tab>

          <Tab title="MMS">
            ```js theme={null}
            var plivo = require('plivo');

             module.exports = {
                 send_sms: function(req, res) {
                     var client = new plivo.Client("<auth_id>", "<auth_token>");
                     client.messages.create({
                         src: "<from_number>",
                         dst: "<to_number>",
                         text: "Hello, MMS from from Sails",
                         type: 'mms',
                         media_urls: ['https://media.giphy.com/media/26gscSULUcfKU7dHq/source.gif'],
                         media_ids: ['801c2056-33ab-499c-80ef-58b574a462a2']
                     }).then(function(response) {
                         return res.status(200).json(response);
                     });
                 }, 
             };
            ```
          </Tab>
        </Tabs>

        Replace the auth placeholders with your authentication credentials from the [Plivo console](https://cx.plivo.com/home). Replace the phone number placeholders with actual phone numbers in [E.164 format](https://en.wikipedia.org/wiki/E.164) (for example, +12025551234). In countries other than the US and Canada you can use a [sender ID](/messaging/concepts/sender-id-usage/) for the message source.

        <Note>
          **Note:** We recommend that you store your credentials in the `auth_id` and `auth_token` environment variables to avoid the possibility of accidentally committing them to source control. If you do this, you can initialize the client with no arguments and Plivo will automatically fetch the values from the environment variables. You can use `process.env` to store environment variables and fetch them when initializing the client.
        </Note>

        Edit **config/route.js** to set the route.

        ```javascript theme={null}
        'POST /send_sms' : 'HelloController.send_sms',
        ```

        ### Test

        Save the file and run it.

        ```shell theme={null}
        $ sails lift
        ```

        You should see your basic server application in action at [http://localhost:1337/send\_sms/](http://localhost:1337/send_sms/).

        ## Receive your first inbound SMS/MMS message

        To receive incoming messages, you must have a Plivo phone number that supports SMS; you can rent numbers from the [Numbers](https://cx.plivo.com/phone-numbers) page of the Plivo console or by using the [Numbers API](/numbers/).

        ### Create a Sails server

        Edit api/controllers/HelloController.js and paste into it this code.

        <Tabs>
          <Tab title="SMS">
            ```js theme={null}
            var plivo = require('plivo');

             module.exports = {
                 receive_sms: function(req, res) {
                     let from_number = req.param("From");
                     let to_number = req.param("To");
                     let text = req.param("Text");
             
                     console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text);
                     
                     return res.status(200).send('message received');
                 },
             };
            ```
          </Tab>

          <Tab title="MMS">
            ```js theme={null}
            var plivo = require('plivo');

             module.exports = {
                 receive_sms: function(req, res) {
                    let from_number = req.param("From");
                    let to_number = req.param("To");
                    let text = req.param("Text");
                    let media_url = req.param("Media0");

                    console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text + ' Media: ' + media_url);
                    
                    return res.status(200).json("message received");
                },
             };
            ```
          </Tab>
        </Tabs>

        Edit config/route.js to set the route.

        ```javascript theme={null}
        'POST /receive_sms' : 'HelloController.receive_sms',
        ```

        Save the file and run it.

        ```shell theme={null}
        $ sails lift
        ```

        You should see your basic server application in action at [http://localhost:1337/receive\_sms/](http://localhost:1337/receive_sms/).

        ### Expose your local server to the internet

        To receive incoming messages, your local server must connect with Plivo API services. For that, we recommend using [ngrok](https://ngrok.com/download), which exposes local servers running behind NATs and firewalls to the public internet over secure tunnels. Using ngrok, you can set webhooks that can talk to the Plivo server.

        <Frame>
          <img src="https://mintcdn.com/plivo/M2NzHE_bNZbCm0gd/images/ngrok-diagram.png?fit=max&auto=format&n=M2NzHE_bNZbCm0gd&q=85&s=b2ef4b4d52c133d126fd0d4303c33a61" alt="ngrok block diagram" width="1626" height="601" data-path="images/ngrok-diagram.png" />
        </Frame>

        Install ngrok and run it on the command line, specifying the port that  hosts the application on which you want to receive messages (80 in this case):

        ```shell theme={null}
        $ ./ngrok http 80
        ```

        This starts the ngrok server on your local server. Ngrok will display a forwarding link that you can use as a webhook to access your local server over the public network.

        <Frame>
          <img src="https://mintcdn.com/plivo/M2NzHE_bNZbCm0gd/images/ngrok.png?fit=max&auto=format&n=M2NzHE_bNZbCm0gd&q=85&s=ce35ccb7eebdb2af565a2a3a2cf2be18" alt="Sample ngrok CLI" width="786" height="238" data-path="images/ngrok.png" />
        </Frame>

        Now people can send messages to your Plivo number.

        ### Create a Plivo application to receive messages

        Associate the controller you created with Plivo by creating a Plivo application. Visiting Messaging > [Applications](https://cx.plivo.com/xml-applications) and click **Add New Application**. You can also use Plivo's [Application API](/account/api/application/#create-an-application).

        Give your application a name — we called ours `Receive SMS`. Enter the server URL you want to use (for example `https://<yourdomain>.com/receive_sms/`) in the `Message URL` field and set the method to `POST`. Click **Create Application** to save your application.

        <Frame>
          <img src="https://mintcdn.com/plivo/2OFvQXVNT3srKLUy/images/create_SMS_app.jpg?fit=max&auto=format&n=2OFvQXVNT3srKLUy&q=85&s=665006f2112a8e6113716029adfbf2a7" alt="Create Application" width="1440" height="785" data-path="images/create_SMS_app.jpg" />
        </Frame>

        ### Assign a Plivo number to your application

        Navigate to the [Numbers](https://cx.plivo.com/phone-numbers) page and select the phone number you want to use for this application.

        From the Application Type drop-down, select `XML Application`.

        From the Plivo Application drop-down, select `Receive SMS` (the name we gave the application).

        Click **Update Number** to save.

        <Frame>
          <img src="https://mintcdn.com/plivo/NFI9_HRHTMInDf93/images/assign_SMS_app.jpg?fit=max&auto=format&n=NFI9_HRHTMInDf93&q=85&s=94324dc41c7e8ade7a60c98e5fe20094" alt="Assign Phone Number to Receive SMS App" width="1440" height="785" data-path="images/assign_SMS_app.jpg" />
        </Frame>

        ### Test

        Send a text message to the Plivo number you specified using any phone.

        ## Reply to an incoming SMS/MMS message

        To receive incoming messages, you must have a Plivo phone number that supports SMS; you can rent numbers from the [Numbers](https://cx.plivo.com/phone-numbers) page of the Plivo console or by using the [Numbers API](/numbers/).

        ### Create a Sails server

        Edit api/controllers/HelloController.js and paste into it this code.

        ```js theme={null}
         var plivo = require('plivo');

         module.exports = {
           reply_sms: function(req, res) {

        ​     let from_number = req.param("From");
        ​     let to_number = req.param("To");
        ​     let text = req.param("Text");

        ​     console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text);

        ​     var response = plivo.Response();
        ​     var params = {
        ​         'src': to_number,
        ​         'dst': from_number,
        ​         'type': "sms",
        ​         'callbackUrl': "https://<yourdomain>.com/sms_status",
        ​         'callbackMethod': "POST"
        ​     };
        ​     var message_body = "This is an automatic response";
        ​     response.addMessage(message_body, params);

        ​     res.setHeader("Content-type", "text/xml");
        ​     return res.status(200).send(response.toXML());
         },

         };
        ```

        Edit config/route.js to set the route.

        ```javascript theme={null}
        'POST /reply_sms' : 'HelloController.reply_sms',
        ```

        Save the file and run it.

        ```shell theme={null}
        $ sails lift
        ```

        You should see your basic server application in action at [http://localhost:1337/reply\_sms/](http://localhost:1337/reply_sms/).

        If you haven’t done so already, [expose your local server to the internet](/sdk/server/setting-up-dev-environment).

        ### Create a Plivo application to reply to messages

        Associate the controller you created with Plivo by creating a Plivo application. Visiting Messaging > [Applications](https://cx.plivo.com/xml-applications) and click **Add New Application**. You can also use Plivo's [Application API](/account/api/application/#create-an-application).

        Give your application a name — we called ours `Reply Incoming SMS`. Enter the server URL you want to use (for example `http://<yourdomain>.com/replysms/`) in the `Message URL` field and set the method to `POST`. Click **Create Application** to save your application.

        <Frame>
          <img src="https://mintcdn.com/plivo/2OFvQXVNT3srKLUy/images/create_reply_sms.png?fit=max&auto=format&n=2OFvQXVNT3srKLUy&q=85&s=0371a975aa748267124e9ea9debc7a0f" alt="Create Application" width="1440" height="822" data-path="images/create_reply_sms.png" />
        </Frame>

        ### Assign a Plivo number to your application

        Navigate to the [Numbers](https://cx.plivo.com/phone-numbers) page and select the phone number you want to use for this application.

        From the Application Type drop-down, select `XML Application`.

        From the Plivo Application drop-down, select `Reply Incoming SMS` (the name we gave the application).

        Click **Update Number** to save.

        ### Test

        Send a text message to the Plivo number you specified using any phone. You should## -use-cases">More use cases

        We illustrate [more than a dozen use cases](/messaging/use-cases/send-an-sms) with code for both API/XML and PHLO on our documentation pages.
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="Node.js & Serverless">
    # Get Started with Node.js Using the Serverless Framework

    ## Sign up for a Plivo account

    When you [sign up with Plivo](https://cx.plivo.com/signup), we give you a free trial account and free credits to experiment with and learn about our services. You can [add a number](https://cx.plivo.com/phone-numbers) to your account to start testing the full range of our voice and SMS service features.

    Follow these steps to get a free trial account:

    1. [Sign up](https://cx.plivo.com/signup) with your work email address.
    2. Check your inbox for an activation email message from Plivo. Click on the link in the message to activate your account.
    3. Enter your mobile number to complete the phone verification step.

    ### Sign up with your work email address

    <Frame>
      <img src="https://mintcdn.com/plivo/Ac6PoKJHHxDx1U63/images/signup.png?fit=max&auto=format&n=Ac6PoKJHHxDx1U63&q=85&s=56190e6fffc6ae0c70dba8c7c69f435b" width="1440" height="900" data-path="images/signup.png" />
    </Frame>

    If you have any issues creating a Plivo account, please contact our [support team](https://support.plivo.com/hc/en-us/) for assistance.

    To get started, try sending an SMS message either by using our API and XML documents, or via {/* [PHLO](/phlo/getting-started/getting-started) */}, our visual design tool, which allows you to create message flows using an intuitive canvas and deploy them with few clicks.

    <Tabs>
      <Tab title="Using API">
        ## Install Node.js, Serverless, Express, and the Plivo Node.js SDK

        You must set up and install Node.js, Serverless, Express, and Plivo Node SDK before you send your first SMS message.

        You also need an AWS account. If you don’t have an account, you can [create one](https://aws.amazon.com/) for free.

        ### Install Node.js

        You can check whether you have Node.js installed under macOS or Linux by running the command `node --version` in a terminal window. Under Windows, open a Windows command prompt or PowerShell and type `node -v`. If you don’t have Node.js installed or want a more current version, <a href="https://nodejs.org/en/download/">download and install it</a>.

        ### Install Serverless, Express, and the Plivo Node.js SDK

        Create a project directory and change into it, then use npm to create a new Node.js project.

        ```shell theme={null}
        $ mkdir my-express-application && cd my-express-application
        $ npm init -f
        ```

        Install Serverless, Express, and the Plivo Node.js SDK using [npm](https://www.npmjs.com/package/plivo).

        ```shell theme={null}
        $ npm install --save serverless-http express plivo
        ```

        You must have your AWS access key credentials loaded in the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables. The Serverless framework accesses the values of these variables to publish the project to AWS. If you've never obtained these credentials from AWS before, the Serverless framework [documentation](https://www.serverless.com/framework/docs/providers/aws/guide/credentials) includes step-by-step instructions on how to do so.

        Once you’ve set up your development environment, you can start sending and receiving messages using our APIs and XML documents. Here are three common use cases to get you started.

        ## Send your first outbound SMS/MMS message

        You must have a Plivo phone number to send messages to the US or Canada; you can rent a Plivo number from Phone Numbers > [Buy Numbers](https://cx.plivo.com/phone-numbers) on the Plivo console or via the [Numbers API](/numbers/api/phone-number/#buy-a-phone-number).

        ### Create a Serverless server

        Create a file called `index.js` and paste into it this code.

        <Tabs>
          <Tab title="SMS">
            ```js theme={null}
            const serverless = require('serverless-http');
            const express = require('express')
            const plivo = require('plivo')
            const app = express()

            app.get('/outbound_sms/', function(request, response) {
               let client = new plivo.Client('<auth_id>', '<auth_token>');
               client.messages.create({
                       src: '<sender_id>',
                       dst: '<destination_number>',
                       text: 'Hello, from Node Express and Serverless!'
                   }

               ).then(function(message_created) {
                   console.log(message_created)
               });
            });

            module.exports.handler = serverless(app);
            ```
          </Tab>

          <Tab title="MMS">
            ```js theme={null}
            const serverless = require('serverless-http');
            const express = require('express')
            const plivo = require('plivo')
            const app = express()

            app.get('/outbound_sms/', function(request, response) {
               let client = new plivo.Client('<auth_id>', '<auth_token>');
               client.messages.create({
                       src: '<sender_id>',
                       dst: '<destination_number>',
                       text: 'Hello, from Node Express and Serverless!',
            type: "mms",
                        media_urls: ["https://media.giphy.com/media/26gscSULUcfKU7dHq/source.gif"],
                        media_ids: ["801c2056-33ab-499c-80ef-58b574a462a2"]

                   }

               ).then(function(message_created) {
                   console.log(message_created)
               });
            });

            module.exports.handler = serverless(app);
            ```
          </Tab>
        </Tabs>

        Replace the auth placeholders with your authentication credentials from the [Plivo console](https://cx.plivo.com/home). Replace the phone number placeholders with actual phone numbers in [E.164 format](https://en.wikipedia.org/wiki/E.164) (for example, +12025551234). In countries other than the US and Canada you can use a [sender ID](/messaging/concepts/sender-id-usage/) for the message source.

        <Note>
          **Note:** We recommend that you store your credentials in the `auth_id` and `auth_token` environment variables to avoid the possibility of accidentally committing them to source control. If you do this, you can initialize the client with no arguments and Plivo will automatically fetch the values from the environment variables. You can use `process.env` to store environment variables and fetch them when initializing the client.
        </Note>

        ### Create a Serverless configuration file

        Copy the code below and save it in a configuration file called `serverless.yml` in the project directory, which Serverless uses  to handle deployments.

        ```yaml theme={null}
        # serverless.yml

        service: my-express-application

        provider:
         name: aws
         runtime: nodejs16.x
         stage: dev
         region: us-east-1

        functions:
         app:
           handler: index.handler
           url: true
        ```

        Run this command to deploy the application.

        ```shell theme={null}
        $ sls deploy
        ```

        <Frame>
          <img src="https://mintcdn.com/plivo/sqGJ0ONkT5kTuesy/images/serverless-deploy.png?fit=max&auto=format&n=sqGJ0ONkT5kTuesy&q=85&s=269af0595f5f877bed9536fb6400487a" alt="Deploy serverless" width="3264" height="1800" data-path="images/serverless-deploy.png" />
        </Frame>

        ### Test

        AWS will report an endpoint on which you can find your application — for example, here it shows <u>[https://mps46xe2isjinod7x5yu5w3kza0hlrld.lambda-url.us-east-1.on.aws/outbound\_sms/](https://mps46xe2isjinod7x5yu5w3kza0hlrld.lambda-url.us-east-1.on.aws/outbound_sms/).</u> Visit that URL and you should see your basic server application in action.

        ## Receive your first inbound SMS/MMS message

        To receive incoming messages, you must have a Plivo phone number that supports SMS; you can rent numbers from the [Numbers](https://cx.plivo.com/phone-numbers) page of the Plivo console or by using the [Numbers API](/numbers/).

        ### Modify the Serverless server

        We will add our code to the `index.js` file we already built.

        <Tabs>
          <Tab title="SMS">
            ```js theme={null}
            const serverless = require('serverless-http');
            const express = require('express')
            const bodyParser = require('body-parser')
            const plivo = require('plivo')
            const app = express()

            app.use(bodyParser.urlencoded({
               extended: true
            }));
            app.use(function(req, response, next) {
               response.contentType('application/xml');
               next();
            });


            app.get('/outbound_sms/', function(request, response) {
            // Send SMS code...
            });


            // receive SMS
            app.get('/receive_sms/', function(request, response) {
               let from_number = request.body.From || request.query.From;
               let to_number = request.body.To || request.query.To;
               let text = request.body.Text || request.query.Text;
               console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text);
            });

            module.exports.handler = serverless(app);
            ```
          </Tab>

          <Tab title="MMS">
            ```js theme={null}
            const serverless = require('serverless-http');
            const express = require('express')
            const plivo = require('plivo')
            const bodyParser = require('body-parser')
            const app = express()

            app.use(bodyParser.urlencoded({
               extended: true
            }));
            app.use(function(req, response, next) {
               response.contentType('application/xml');
               next();
            });


            app.get('/outbound_mms/', function(request, response) {
            // Send MMS code ...
            });


            // receive MMS
            app.get('/receive_mms/', function(request, response) {
               let from_number = request.body.From || request.query.From;
               let to_number = request.body.To || request.query.To;
               let text = request.body.Text || request.query.Text;
               let media_url = request.body.Media0 || request.query.Media0;
                console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text+ ', Media: ' + media_url);
            });

            module.exports.handler = serverless(app); 
            ```
          </Tab>
        </Tabs>

        Run this command to deploy the application.

        ```shell theme={null}
        $ sls deploy
        ```

        <Frame>
          <img src="https://mintcdn.com/plivo/sqGJ0ONkT5kTuesy/images/serverless-deploy.png?fit=max&auto=format&n=sqGJ0ONkT5kTuesy&q=85&s=269af0595f5f877bed9536fb6400487a" alt="Deploy serverless" width="3264" height="1800" data-path="images/serverless-deploy.png" />
        </Frame>

        AWS will report an endpoint on which you can find your application — for example, here it shows <u>[https://mps46xe2isjinod7x5yu5w3kza0hlrld.lambda-url.us-east-1.on.aws/receive\_sms/](https://mps46xe2isjinod7x5yu5w3kza0hlrld.lambda-url.us-east-1.on.aws/receive_sms/)</u>. Visit that URL and you should see your basic server application in action.

        ### Create a Plivo application to receive messages

        Associate the controller you created with Plivo by creating a Plivo application. Visiting Messaging > [Applications](https://cx.plivo.com/xml-applications) and click **Add New Application**. You can also use Plivo's [Application API](/account/api/application/#create-an-application).

        Give your application a name — we called ours `Receive SMS`. Enter the server URL you want to use (for example `https://<yourdomain>.com/receive_sms/`) in the `Message URL` field and set the method to `GET`. Click **Create Application** to save your application.

        <Frame>
          <img src="https://mintcdn.com/plivo/7-odxN9fJG_Dg1dt/images/receive-sms.png?fit=max&auto=format&n=7-odxN9fJG_Dg1dt&q=85&s=59d6ea6afd8c9b16bba8c6f1e6f02b72" alt="Create Application" width="2048" height="1168" data-path="images/receive-sms.png" />
        </Frame>

        ### Assign a Plivo number to your application

        Navigate to the [Numbers](https://cx.plivo.com/phone-numbers) page and select the phone number you want to use for this application.

        From the Application Type drop-down, select `XML Application`.

        From the Plivo Application drop-down, select `Receive SMS` (the name we gave the application).

        Click **Update Number** to save.

        <Frame>
          <img src="https://mintcdn.com/plivo/NFI9_HRHTMInDf93/images/assign_SMS_app.jpg?fit=max&auto=format&n=NFI9_HRHTMInDf93&q=85&s=94324dc41c7e8ade7a60c98e5fe20094" alt="Assign Phone Number to Receive SMS App" width="1440" height="785" data-path="images/assign_SMS_app.jpg" />
        </Frame>

        ### Test

        Send a text message to the Plivo number you specified using any phone.

        ## Reply to an incoming SMS/MMS message

        To receive incoming messages, you must have a Plivo phone number that supports SMS; you can rent numbers from the [Numbers](https://cx.plivo.com/phone-numbers) page of the Plivo console or by using the [Numbers API](/numbers/).

        ### Modify the Serverless server

        We will add our code to the `index.js` file we already built.

        ```js theme={null}
        const serverless = require('serverless-http');
        const express = require('express')
        const bodyParser = require('body-parser')
        const plivo = require('plivo')
        const app = express()

        app.use(bodyParser.urlencoded({
           extended: true
        }));
        app.use(function(req, response, next) {
           response.contentType('application/xml');
           next();
        });


        app.get('/outbound_sms/', function(request, response) {
          //Send SMS code...
        });


        app.get('/receive_sms/', function(request, response) {
           // Receive SMS code...
        });


        // reply incoming SMS/MMS
        app.get('/reply_sms/', function(request, response) {
           let from_number = request.body.From || request.query.From;
           let to_number = request.body.To || request.query.To;
           let text = request.body.Text || request.query.Text;
           console.log('Message received - From: ' + from_number + ', To: ' + to_number + ', Text: ' + text);

           //send the details to generate an XML
           let r = plivo.Response();
           let params = {
               'src': to_number,
               'dst': from_number,
           };
           let message_body = "This is an automatic response";
           r.addMessage(message_body, params);
           console.log(r.toXML());
           response.end(r.toXML());
        });

        module.exports.handler = serverless(app);
        ```

        Run this command to deploy the application.

        ```shell theme={null}
        $ sls deploy
        ```

        <Frame>
          <img src="https://mintcdn.com/plivo/sqGJ0ONkT5kTuesy/images/serverless-deploy.png?fit=max&auto=format&n=sqGJ0ONkT5kTuesy&q=85&s=269af0595f5f877bed9536fb6400487a" alt="Deploy serverless" width="3264" height="1800" data-path="images/serverless-deploy.png" />
        </Frame>

        AWS will report an endpoint on which you can find your application — for example, here it shows <u>[https://mps46xe2isjinod7x5yu5w3kza0hlrld.lambda-url.us-east-1.on.aws/reply\_sms/](https://mps46xe2isjinod7x5yu5w3kza0hlrld.lambda-url.us-east-1.on.aws/reply_sms/)</u>. Visit that URL and you should see your basic server application in action.

        ### Create a Plivo application to reply to messages

        Associate the controller you created with Plivo by creating a Plivo application. Visiting Messaging > [Applications](https://cx.plivo.com/xml-applications) and click **Add New Application**. You can also use Plivo's [Application API](/account/api/application/#create-an-application).

        Give your application a name — we called ours `Reply Incoming SMS`. Enter the server URL you want to use (for example `http://<yourdomain>.com/reply_sms/`) in the `Message URL` field and set the method to `GET`. Click **Create Application** to save your application.

        <Frame>
          <img src="https://mintcdn.com/plivo/7-odxN9fJG_Dg1dt/images/reply-sms.png?fit=max&auto=format&n=7-odxN9fJG_Dg1dt&q=85&s=3cd257d00a7d40882b354b0342cba865" alt="Create Application" width="1600" height="913" data-path="images/reply-sms.png" />
        </Frame>

        ### Assign a Plivo number to your application

        Navigate to the [Numbers](https://cx.plivo.com/phone-numbers) page and select the phone number you want to use for this application.

        From the Application Type drop-down, select `XML Application`.

        From the Plivo Application drop-down, select `Reply Incoming SMS` (the name we gave the application).

        Click **Update Number** to save.

        ### Assign a Plivo number to your application

        Send a text message to the Plivo number you specified using any phone. You should receive a reply.

        ## More use cases

        We illustrate [more than a dozen use cases](/messaging/use-cases/send-an-sms) with code for both API/XML and PHLO on our documentation pages.
      </Tab>
    </Tabs>
  </Tab>
</Tabs>