[Yandex Cloud documentation](../../index.md) > [Tutorials](../index.md) > [Serverless technologies](index.md) > Sending emails in Yandex Cloud Postbox using the AWS SDK > JavaScript

# Sending emails using the AWS SDK for JavaScript

In this tutorial, you will learn how to send emails via Yandex Cloud Postbox using the [AWS SDK for JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/welcome.html).

To start sending emails:

1. [Get your cloud ready](#before-begin).
1. [Configure a directory for authentication data](#auth).
1. [Create and run the application](#app).
1. [Check the result](#check-result).

If you no longer need the resources you created, [delete them](#clear-out).


## Get your cloud ready {#before-begin}

Sign up for Yandex Cloud and create a [billing account](../../billing/concepts/billing-account.md):
1. Navigate to the [management console](https://console.yandex.cloud) and log in to Yandex Cloud or create a new account.
1. On the **[Yandex Cloud Billing](https://center.yandex.cloud/billing/accounts)** page, make sure you have a billing account linked and it has the `ACTIVE` or `TRIAL_ACTIVE` [status](../../billing/concepts/billing-account-statuses.md). If you do not have a billing account, [create one](../../billing/quickstart/index.md) and [link](../../billing/operations/pin-cloud.md) a cloud to it.

If you have an active billing account, you can create or select a [folder](../../resource-manager/concepts/resources-hierarchy.md#folder) for your infrastructure on the [cloud page](https://console.yandex.cloud/cloud).

[Learn more about clouds and folders here](../../resource-manager/concepts/resources-hierarchy.md).


### Required paid resources {#paid-resources}

The infrastructure support costs include:

* Fee for using Yandex Cloud Postbox (see [Yandex Cloud Postbox pricing](../../postbox/pricing.md)).
* Fee for public DNS queries and [DNS zones](../../dns/concepts/dns-zone.md), if you are creating a resource record in Cloud DNS (see [Cloud DNS pricing](../../dns/pricing.md)).


### Set up resources {#infrastructure}

1. [Create](../../iam/operations/sa/create.md) a service account.
1. [Assign](../../iam/operations/sa/assign-role-for-sa.md) the `postbox.sender` [role](../../postbox/security/index.md#postbox-sender) to the service account.
1. [Create](../../iam/operations/authentication/manage-access-keys.md) a static access key for the service account. Save the ID and secret key.
1. Create an [address](../../postbox/operations/create-address.md).
1. [Pass](../../postbox/operations/check-domain.md) a domain ownership check.


## Configure a directory for authentication data {#auth}

1. Create a directory to store the authentication data in and navigate to it: 

    For macOS and Linux:

    ```bash
    mkdir ~/.aws/
    ```

    For Windows:

    ```bash
    mkdir C:\Users\<user_name>\.aws\
    ```

1. In the `.aws` directory, create a file named `credentials`, copy the credentials you got when [creating a static access key](#infrastructure), and paste them into it:

    ```text
    [default]
    aws_access_key_id = <static_key_ID>
    aws_secret_access_key = <secret_key>
    ```

1. Create a file named `config` with the default region settings and copy the following information to it:

    ```text
    [default]
    region = ru-central1
    endpoint_url = https://postbox.cloud.yandex.net
    ```


### Using environment variables {#variables}

By default, the AWS SDK uses authentication data from environment variables if they are set. These variables have priority over authentication data from the `.aws/credentials` file.

The following environment variables are supported:

* `AWS_ACCESS_KEY_ID`: Static key ID.
* `AWS_SECRET_ACCESS_KEY`: Secret key.

To set environment variables, depending on your operating system, follow these steps:

{% list tabs group=operating_system %}

- Linux/macOS

    In the terminal, run this command:

    ```bash
    export AWS_ACCESS_KEY_ID=<static_key_ID>
    export AWS_SECRET_ACCESS_KEY=<secret_key>
    ```

- Windows

    In PowerShell, run:

    ```powershell
    $Env:AWS_ACCESS_KEY_ID=<static_key_ID>
    $Env:AWS_SECRET_ACCESS_KEY=<secret_key>
    ```

{% endlist %}


## Create and run the application {#app}

1. Get the application code:

    {% list tabs %}

    - Repository

      1. Clone the repository:
         
         ```bash
         git clone https://github.com/yandex-cloud-examples/yc-postbox-examples
         ```
      1. Navigate to the folder in the cloned `javascript/` repository.
      1. In the `main.js` file, specify the following:
         
         * Sender's email address in the `SENDER` field.
         
             The sender's email domain must match the one specified in the Yandex Cloud Postbox address you created when [getting started](#infrastructure). For example, if your verified domain is `yourdomain.com`, you can use addresses like `noreply@yourdomain.com` or `admin@yourdomain.com` but not `user@mail.yourdomain.com`.
         
         * Recipient's email address in the `RECIPIENT` field, e.g., `receiver@yourdomain.com`. You will need access to this email address for the next step.

    - Manually

      1. Create a directory named `postbox-javascript` and open it.
      1. Create a file named `main.js` and paste this code into it:

          ```javascript
          // AWS SDK for JavaScript v3 (ESM)
          import { SESv2Client, SendEmailCommand } from '@aws-sdk/client-sesv2';

          // The sender's address must be verified using Amazon SES.
          const SENDER = "<sender_address>";

          // Recipient's address.
          const RECIPIENT = "<recipient_address>";

          // Email subject.
          const SUBJECT = "Yandex Cloud Postbox Test via AWS SDK for JavaScript v3";

          // HTML text of the email.
          const HTML_BODY = `<h1>Amazon SES Test Email (AWS SDK for JavaScript v3)</h1>
          <p>This email was sent with <a href='https://yandex.cloud/en/docs/postbox/quickstart'>Yandex Cloud Postbox</a> using the 
          <a href='https://aws.amazon.com/sdk-for-javascript/'>AWS SDK for JavaScript v3</a>.</p>`;

          // Email text for email clients without HTML support.
          const TEXT_BODY = "This email was sent with Yandex Cloud Postbox using the AWS SDK for JavaScript v3.";

          // Character encoding in the email.
          const CHARSET = "UTF-8";

          // Main function
          async function main() {
              // Create a SES client with an endpoint for Yandex Cloud Postbox
              const client = new SESv2Client({
                  region: 'ru-central1',
                  endpoint: 'https://postbox.cloud.yandex.net',
                  // By default, the SDK uses the default credential provider chain.
                  // You can use static credentials by uncommenting and changing the following lines:
                  // credentials: {
                  //     accessKeyId: 'accessKeyID',
                  //     secretAccessKey: 'secretAccessKey',
                  // },
              });

              // Building the email.
              const params = {
                  Destination: {
                      ToAddresses: [RECIPIENT],
                  },
                  Content: {
                      Simple: {
                          Subject: {
                              Charset: CHARSET,
                              Data: SUBJECT,
                          },
                          Body: {
                              Html: {
                                  Charset: CHARSET,
                                  Data: HTML_BODY,
                              },
                              Text: {
                                  Charset: CHARSET,
                                  Data: TEXT_BODY,
                              },
                          },
                      },
                  },
                  FromEmailAddress: SENDER,
              };

              try {
                  // Creating a command.
                  const command = new SendEmailCommand(params);

                  // Sending the email.
                  const data = await client.send(command);
                  console.log(data.MessageId);
              } catch (err) {
                  console.error("Error sending email:", err);
                  throw err;
              }
          }

          // Running the main function.
          main().catch(err => {
              console.error("Unhandled error:", err);
              process.exit(1);
          });
          ```

      1. In the `main.js` file, specify the following:
         
         * Sender's email address in the `SENDER` field.
         
             The sender's email domain must match the one specified in the Yandex Cloud Postbox address you created when [getting started](#infrastructure). For example, if your verified domain is `yourdomain.com`, you can use addresses like `noreply@yourdomain.com` or `admin@yourdomain.com` but not `user@mail.yourdomain.com`.
         
         * Recipient's email address in the `RECIPIENT` field, e.g., `receiver@yourdomain.com`. You will need access to this email address for the next step.
      1. Create a file named `package.json` and paste this code into it:

          ```json
          {
            "name": "yc-postbox-example",
            "version": "1.0.0",
            "description": "Example of sending emails through Yandex Cloud Postbox using AWS SDK for JavaScript",
            "main": "main.js",
            "type": "module",
            "scripts": {
              "start": "node main.js"
            },
            "dependencies": {
              "@aws-sdk/client-sesv2": "^3.821.0"
            },
            "license": "MIT"
          }
          ```

    {% endlist %}

1. Install the dependencies:

    ```bash
    npm install
    ```

    Result:

    ```text
    added 79 packages, and audited 80 packages in 3s
    
    3 packages are looking for funding
      run `npm fund` for details
    
    found 0 vulnerabilities
    ```

  1. Run the application:

      ```bash
      npm start
      ```

      Result:

      ```text
      > yc-postbox-example@1.0.0 start
      > node main.js

      DB6TZYXAOBH1.2E2Q5********@ingress2-klg
      ```


## Check the result {#check-result}

Make sure the recipient specified in the file named `main.js` in the `RECIPIENT` field has received an email with the specified parameters.


## How to delete the resources you created {#clear-out}

To stop paying for the resources you created:

1. Delete the [address](../../postbox/concepts/glossary.md#adress).
1. [Delete](../../dns/operations/zone-delete.md) the DNS zone if you created a resource record in it.