Sender Identities

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->getAll($domainId = 'domainId', $page = 1, $limit = 10);

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.email.identity.list()
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, IdentityBuilder

ms = MailerSendClient()

request = (IdentityBuilder()
          .domain_id("domain-id")
          .build_list_request())

response = ms.identities.list_identities(request)

package main

import (
	"context"
	"log"
	"time"
	
	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	// Create an instance of the mailersend client
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	domainID := "domain-id"
	options := &mailersend.ListIdentityOptions{
		DomainID: domainID,
		Page:     1,
		Limit:    25,
	}

	_, _, err := ms.Identity.List(ctx, options)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;
import com.mailersend.sdk.senderidentities.SenderIdentitiesList;
import com.mailersend.sdk.senderidentities.SenderIdentity;

public void getSenderIdentities() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        SenderIdentitiesList list = ms.senderIdentities()
                .page(1)
                .limit(25)
                .getIdentities();

        for (SenderIdentity identity : list.identities) {
            System.out.println(identity.id);
            System.out.println(identity.email);
            System.out.println(identity.name);
            System.out.println(identity.isVerified);
        }

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_sender_identity = Mailersend::SenderIdentity.new(ms_client)
ms_sender_identity.list

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->find('identityId');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.email.identity.single("identity_id")
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, IdentityBuilder

ms = MailerSendClient()

request = (IdentityBuilder()
          .identity_id("identity-id")
          .build_get_request())

response = ms.identities.get_identity(request)

package main

import (
	"context"
	"log"
	"time"
	
	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	// Create an instance of the mailersend client
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()
	
	identityID := "identity-id"

	_, _, err := ms.Identity.Get(ctx, identityID)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;
import com.mailersend.sdk.senderidentities.SenderIdentity;

public void getSenderIdentity() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        SenderIdentity identity = ms.senderIdentities().getIdentity("your-identity-id");

        System.out.println(identity.id);
        System.out.println(identity.email);
        System.out.println(identity.name);
        System.out.println(identity.isVerified);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_sender_identity = Mailersend::SenderIdentity.new(ms_client)
ms_sender_identity.single(identity_id: 'idofidentity123')

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->findByEmail('email');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
    apiKey: process.env.API_KEY,
});

mailerSend.email.identity.singleByEmail('email_address')
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, IdentityBuilder

ms = MailerSendClient()

request = (IdentityBuilder()
          .email("support@yourdomain.com")
          .build_get_by_email_request())

response = ms.identities.get_identity_by_email(request)

package main

import (
	"context"
	"os"
	"log"
	"time"

	"github.com/mailersend/mailersend-go"
)

func main() {
	// Create an instance of the mailersend client
	ms := mailersend.NewMailersend(os.Getenv("MAILERSEND_API_KEY"))

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	_, _, err := ms.Identity.GetByEmail(ctx, "identity-email")
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;
import com.mailersend.sdk.senderidentities.SenderIdentity;

public void getSenderIdentityByEmail() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        SenderIdentity identity = ms.senderIdentities().getIdentityByEmail("sender@yourdomain.com");

        System.out.println(identity.id);
        System.out.println(identity.email);
        System.out.println(identity.name);
        System.out.println(identity.isVerified);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_sender_identity = Mailersend::SenderIdentity.new(ms_client)
ms_sender_identity.single_by_email(email: 'example@email.com')

{
  "domain_id": "7nxe3yjmeq28vp0k",
  "email": "pedro@test.com",
  "name": "Pedro Doe",
  "personal_note": "Hi Pedro, please confirm this email by clicking on the link below.",
  "reply_to_name": "Test Doe",
  "reply_to_email": "test@test.com",
  "add_note": true
}

use MailerSend\MailerSend;
use MailerSend\Helpers\Builder\SenderIdentity;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->create(
    (new SenderIdentity('domainId', 'name', 'email'))
        ->setReplyToName("John Doe")
        ->setReplyToEmail("john@test.com")
        ->setAddNote(true)
        ->setPersonalNote("Hi John, please use this token")
);

import 'dotenv/config';
import { MailerSend, Identity } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

const identity = new Identity()
    .setDomainId('domain_id')
    .setEmail('identity@yourdomain.com')
    .setName('Name')
    .setReplyToEmail('reply_identity@yourdomain.com')
    .setReplyToName('Reply Name')
    .setAddNote(false);

mailerSend.email.identity.create(identity)
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, IdentityBuilder

ms = MailerSendClient()

request = (IdentityBuilder()
          .domain_id("domain-id")
          .name("John Doe")
          .email("john@yourdomain.com")
          .reply_to_email("support@yourdomain.com")
          .reply_to_name("Support Team")
          .add_note(True)
          .build_create_request())

response = ms.identities.create_identity(request)

package main

import (
	"context"
	"log"
	"time"
	
	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	// Create an instance of the mailersend client
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	options := &mailersend.CreateIdentityOptions{
		DomainID:     "domain-id",
		Name:         "John Doe",
		Email:        "john@yourdomain.com",
		ReplyToEmail: "support@yourdomain.com",
		ReplyToName:  "Support Team",
		AddNote:      true,
	}

	_, _, err := ms.Identity.Create(ctx, options)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;
import com.mailersend.sdk.senderidentities.SenderIdentity;

public void createSenderIdentity() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        SenderIdentity identity = ms.senderIdentities().builder()
                .domainId("your-domain-id")
                .email("sender@yourdomain.com")
                .name("Sender Name")
                .replyToEmail("reply@yourdomain.com")
                .replyToName("Reply Name")
                .addNote(true)
                .personalNote("Please verify this sender identity.")
                .createIdentity();

        System.out.println(identity.id);
        System.out.println(identity.email);
        System.out.println(identity.isVerified);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_sender_identity = Mailersend::SenderIdentity.new(ms_client)
ms_sender_identity.add(domain_id: 'idofdomain12412', name: 'yourname', email: 'sender@yourdomain.com')

{
  "name": "Pedro Doe",
  "reply_to_name": "Test Doe",
  "reply_to_email": "test@test.com"
}

use MailerSend\MailerSend;
use MailerSend\Helpers\Builder\SenderIdentity;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->update(
    'identityId',
    (new SenderIdentity('domainId', 'name', 'email'))
        ->setReplyToName("John Doe")
        ->setReplyToEmail("john@test.com")
);

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

const data = {
  name: 'name',
  reply_to_name: 'Reply Name',
  reply_to_email: 'reply@yourdomain.com',
};

mailerSend.email.identity.update('identity_id', data)
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, IdentityBuilder

ms = MailerSendClient()

request = (IdentityBuilder()
          .identity_id("identity-id")
          .name("Jane Doe")
          .reply_to_email("support@yourdomain.com")
          .reply_to_name("Support Team")
          .add_note(True)
          .personal_note("Please verify this sender identity.")
          .build_update_request())

response = ms.identities.update_identity(request)

package main

import (
	"context"
	"log"
	"time"
	
	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	// Create an instance of the mailersend client
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	identityID := "identity-id"
	options := &mailersend.UpdateIdentityOptions{
		Name:         "Jane Doe",
		ReplyToEmail: "support@yourdomain.com",
		ReplyToName:  "Support Team",
		AddNote:      true,
		PersonalNote: "Please verify this sender identity.",
	}

	_, _, err := ms.Identity.Update(ctx, identityID, options)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;
import com.mailersend.sdk.senderidentities.SenderIdentity;

public void updateSenderIdentity() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        SenderIdentity identity = ms.senderIdentities().builder()
                .name("Updated Sender Name")
                .replyToEmail("newreply@yourdomain.com")
                .replyToName("New Reply Name")
                .updateIdentity("your-identity-id");

        System.out.println(identity.id);
        System.out.println(identity.name);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_sender_identity = Mailersend::SenderIdentity.new(ms_client)
ms_sender_identity.update(identity_id: 'idofidentity123', reply_to_email: 'reply@yourdomain.com', reply_to_name: 'replyname', add_note: true, personal_note: 'Please verify this sender identity.')

{
  "name": "Pedro Doe",
  "reply_to_name": "Test Doe",
  "reply_to_email": "test@test.com"
}

use MailerSend\MailerSend;
use MailerSend\Helpers\Builder\SenderIdentity;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->updateByEmail(
    'email',
    (new SenderIdentity('domainId', 'name', 'email'))
        ->setReplyToName("John Doe")
        ->setReplyToEmail("john@test.com")
);

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

const data = {
  name: 'name',
  reply_to_name: 'Reply Name',
  reply_to_email: 'reply@yourdomain.com',
};

mailerSend.email.identity.updateByEmail('email_address', data)
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, IdentityBuilder

ms = MailerSendClient()

request = (IdentityBuilder()
          .email("support@yourdomain.com")
          .name("Doe Jane")
          .reply_to_email("support@yourdomain.com")
          .reply_to_name("Support Team")
          .add_note(True)
          .personal_note("Please verify this sender identity.")
          .build_update_by_email_request())

response = ms.identities.update_identity_by_email(request)

package main

import (
	"context"
	"log"
	"time"
	
	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	// Create an instance of the mailersend client
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	email := "support@yourdomain.com"
	options := &mailersend.UpdateIdentityOptions{
		Name:         "Doe Jane",
		ReplyToEmail: "support@yourdomain.com",
		ReplyToName:  "Support Team",
		AddNote:      true,
		PersonalNote: "Please verify this sender identity.",
	}

	_, _, err := ms.Identity.UpdateByEmail(ctx, email, options)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;
import com.mailersend.sdk.senderidentities.SenderIdentity;

public void updateSenderIdentityByEmail() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        SenderIdentity identity = ms.senderIdentities().builder()
                .name("Updated Sender Name")
                .replyToEmail("newreply@yourdomain.com")
                .replyToName("New Reply Name")
                .updateIdentityByEmail("sender@yourdomain.com");

        System.out.println(identity.id);
        System.out.println(identity.name);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_sender_identity = Mailersend::SenderIdentity.new(ms_client)
ms_sender_identity.update_by_email(email: 'example@email.com', reply_to_email: 'reply@yourdomain.com', reply_to_name: 'replyname', add_note: true, personal_note: 'Please verify this sender identity.')

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->delete('identityId');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.email.identity.delete("identity_id")
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, IdentityBuilder

ms = MailerSendClient()

request = (IdentityBuilder()
          .identity_id("identity-id")
          .build_delete_request())

response = ms.identities.delete_identity(request)

package main

import (
	"context"
	"log"
	"time"
	
	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	// Create an instance of the mailersend client
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()
	
	identityID := "identity-id"

	_, err := ms.Identity.Delete(ctx, identityID)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;

public void deleteSenderIdentity() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        boolean deleted = ms.senderIdentities().deleteIdentity("your-identity-id");

        System.out.println("Identity deleted: " + deleted);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_sender_identity = Mailersend::SenderIdentity.new(ms_client)
ms_sender_identity.delete(identity_id: 'idofidentity123')

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->deleteByEmail('email');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
    apiKey: process.env.API_KEY,
});

mailerSend.email.identity.deleteByEmail('email_address')
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

from mailersend import MailerSendClient, IdentityBuilder

ms = MailerSendClient()

request = (IdentityBuilder()
          .email("support@yourdomain.com")
          .build_delete_by_email_request())

response = ms.identities.delete_identity_by_email(request)

package main

import (
	"context"
	"log"
	"time"
	
	"github.com/mailersend/mailersend-go"
)

var APIKey = "Api Key Here"

func main() {
	// Create an instance of the mailersend client
	ms := mailersend.NewMailersend(APIKey)

	ctx := context.Background()
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()
	
	email := "support@yourdomain.com"

	_, err := ms.Identity.DeleteByEmail(ctx, email)
	if err != nil {
		log.Fatal(err)
	}
}

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;

public void deleteSenderIdentityByEmail() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        boolean deleted = ms.senderIdentities().deleteIdentityByEmail("sender@yourdomain.com");

        System.out.println("Identity deleted: " + deleted);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}

require "mailersend-ruby"

ms_client = Mailersend::Client.new('your_mailersend_token')

ms_sender_identity = Mailersend::SenderIdentity.new(ms_client)
ms_sender_identity.delete_by_email(email: 'example@email.com')

use MailerSend\MailerSend;

$mailersend = new MailerSend(['api_key' => 'key']);

$mailersend->senderIdentity->resend('identityId');

import 'dotenv/config';
import { MailerSend } from "mailersend";

const mailerSend = new MailerSend({
  apiKey: process.env.API_KEY,
});

mailerSend.email.identity.resend("identity_id")
    .then((response) => console.log(response.body))
    .catch((error) => console.log(error.body));

import com.mailersend.sdk.MailerSend;
import com.mailersend.sdk.exceptions.MailerSendException;
import com.mailersend.sdk.senderidentities.SenderIdentity;

public void resendSenderIdentityConfirmation() {

    MailerSend ms = new MailerSend();
    ms.setToken("Your API token");

    try {

        SenderIdentity identity = ms.senderIdentities().resendConfirmation("your-identity-id");

        System.out.println("Confirmation resent. Resend count: " + identity.resends);

    } catch (MailerSendException e) {
        e.printStackTrace();
    }
}