# Senders Calls

## Introduction

Senders represent sender addresses or domains which have been validated on Mailjet's system to send transactional emails.
The Mailjet resource matching the `senders` Mandrill resource is [`sender`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/).

## List

Info
Maps to /senders/list.json

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$response = $mj->get(Resources::$Sender);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
curl -s \
	-X GET \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/sender
```

Node.js
```javascript
/**
 *
 * View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet.get('sender').request()
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
Mailjet.configure do |config|
  config.api_key = ENV['MJ_APIKEY_PUBLIC']
  config.secret_key = ENV['MJ_APIKEY_PRIVATE']
  config.default_from = 'your default sending address'
end
variable = Mailjet::Sender.all()
```

Python
```python
"""
View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
"""
from mailjet_rest import Client
import os
api_key = os.environ['MJ_APIKEY_PUBLIC']
api_secret = os.environ['MJ_APIKEY_PRIVATE']
mailjet = Client(auth=(api_key, api_secret))
result = mailjet.sender.get()
print result.status_code
print result.json()
```

Go
```go
/*
View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
*/
package main
import (
	"fmt"
	. "github.com/mailjet/mailjet-apiv3-go"
	"github.com/mailjet/mailjet-apiv3-go/resources"
	"os"
)
func main () {
	mailjetClient := NewMailjetClient(os.Getenv("MJ_APIKEY_PUBLIC"), os.Getenv("MJ_APIKEY_PRIVATE"))
	var data []resources.Sender
	_, _, err := mailjetClient.List("sender", &data)
	if err != nil {
	  fmt.Println(err)
	}
	fmt.Printf("Data array: %+v\n", data)
}
```

Java
```java
package com.my.project;
import com.mailjet.client.errors.MailjetException;
import com.mailjet.client.MailjetClient;
import com.mailjet.client.MailjetRequest;
import com.mailjet.client.MailjetResponse;
import com.mailjet.client.resource.Sender;
public class MyClass {
    /**
     * View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(Sender.resource);
      response = client.get(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

```json
{
  "Count": 1,
  "Data": [
    {
      "CreatedAt": "2015-09-07T06:59:52Z",
      "DNSID": "1",
      "Email": "anothersender@example.com",
      "EmailType": "unknown",
      "Filename": "0123456789abcdef.txt",
      "ID": "1",
      "IsDefaultSender": "false",
      "Name": "Myname",
      "Status": "Inactive"
    }
  ],
  "Total": 1
}
```

Issue a `GET` request on the [`sender`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/) resource.

## Domains

Info
Maps to /senders/domains.json

The senders domains are included in the `sender` resource. A sender domain is represented in the form of "*@domain.com".

## Add-Domain

Info
Maps to /senders/add-domain.json

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$response = $mj->get(Resources::$Dns);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# View : Sender Domain properties.
curl -s \
	-X GET \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/dns
```

Node.js
```javascript
/**
 *
 * View : Sender Domain properties.
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet.get('dns').request()
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# View : Sender Domain properties.
Mailjet.configure do |config|
  config.api_key = ENV['MJ_APIKEY_PUBLIC']
  config.secret_key = ENV['MJ_APIKEY_PRIVATE']
  config.default_from = 'your default sending address'
end
variable = Mailjet::Dns.all()
```

Python
```python
"""
View : Sender Domain properties.
"""
from mailjet_rest import Client
import os
api_key = os.environ['MJ_APIKEY_PUBLIC']
api_secret = os.environ['MJ_APIKEY_PRIVATE']
mailjet = Client(auth=(api_key, api_secret))
result = mailjet.dns.get()
print result.status_code
print result.json()
```

Go
```go
/*
View : Sender Domain properties.
*/
package main
import (
	"fmt"
	. "github.com/mailjet/mailjet-apiv3-go"
	"github.com/mailjet/mailjet-apiv3-go/resources"
	"os"
)
func main () {
	mailjetClient := NewMailjetClient(os.Getenv("MJ_APIKEY_PUBLIC"), os.Getenv("MJ_APIKEY_PRIVATE"))
	var data []resources.Dns
	_, _, err := mailjetClient.List("dns", &data)
	if err != nil {
	  fmt.Println(err)
	}
	fmt.Printf("Data array: %+v\n", data)
}
```

Java
```java
package com.my.project;
import com.mailjet.client.errors.MailjetException;
import com.mailjet.client.MailjetClient;
import com.mailjet.client.MailjetRequest;
import com.mailjet.client.MailjetResponse;
import com.mailjet.client.resource.Dns;
public class MyClass {
    /**
     * View : Sender Domain properties.
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(Dns.resource);
      response = client.get(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

```json
{
  "Count": 1,
  "Data": [
    {
      "DKIMRecordName": "",
      "DKIMRecordValue": "",
      "DKIMStatus": "",
      "Domain": "",
      "ID": "",
      "IsCheckInProgress": "false",
      "LastCheckAt": "",
      "OwnerShipToken": "",
      "OwnerShipTokenRecordName": "",
      "SPFRecordValue": "",
      "SPFStatus": ""
    }
  ],
  "Total": 1
}
```

Everytime you post a new sender (address or domain) which doesn't map to an existing domain in the Mailjet system, a new [`dns`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/) resource is created. You can then issue `GET` request on this request, using the ID or the domain name. The `dns` resource provides you with all the information you need to setup your domain in a valid way to start sending using a related sender address or domain.

## Check-Domain

Info
Maps to /senders/check-domain.json

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$response = $mj->post(Resources::$DnsCheck, ['id' => $id]);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# Check : Run a check on a domain
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/dns/$ID_OR_DOMAINNAME/check \
	-H 'Content-Type: application/json' \
	-d '{
	}'
```

Node.js
```javascript
/**
 *
 * Check : Run a check on a domain
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet
  .post('dns')
  .id($ID_OR_DOMAINNAME)
  .action('check')
  .request()
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# Check : Run a check on a domain
Mailjet.configure do |config|
  config.api_key = ENV['MJ_APIKEY_PUBLIC']
  config.secret_key = ENV['MJ_APIKEY_PRIVATE']
  config.default_from = 'your default sending address'
end
variable = Mailjet::Dns_check.create(id: $ID_OR_DOMAINNAME)
```

Python
```python
"""
Check : Run a check on a domain
"""
from mailjet_rest import Client
import os
api_key = os.environ['MJ_APIKEY_PUBLIC']
api_secret = os.environ['MJ_APIKEY_PRIVATE']
mailjet = Client(auth=(api_key, api_secret))
id = '$ID_OR_DOMAINNAME'
result = mailjet.dns_check.create(id=id)
print result.status_code
print result.json()
```

Java
```java
package com.my.project;
import com.mailjet.client.errors.MailjetException;
import com.mailjet.client.MailjetClient;
import com.mailjet.client.MailjetRequest;
import com.mailjet.client.MailjetResponse;
import com.mailjet.client.resource.DnsCheck;
public class MyClass {
    /**
     * Check : Run a check on a domain
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(DnsCheck.resource, ID);
      response = client.post(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

Go
```go
/*
Check : Run a check on a domain
*/
package main
import (
	"fmt"
	. "github.com/mailjet/mailjet-apiv3-go"
	"github.com/mailjet/mailjet-apiv3-go/resources"
	"os"
)
func main () {
	mailjetClient := NewMailjetClient(os.Getenv("MJ_APIKEY_PUBLIC"), os.Getenv("MJ_APIKEY_PRIVATE"))
	var data []resources.DnsCheck
	mr := &MailjetRequest{
	  Resource: "dns",
	  ID: RESOURCE_ID,
	  Action: "check",
	}
	fmr := &FullMailjetRequest{
	  Info: mr,
	  Payload: &resources.DnsCheck {
    },
	}
	err := mailjetClient.Post(fmr, &data)
	if err != nil {
	  fmt.Println(err)
	}
	fmt.Printf("Data array: %+v\n", data)
}
```

```json
{
  "Count": 1,
  "Data": [
    {
      "DKIMErrors": ["no DKIM record"],
      "DKIMRecordCurrentValue": "",
      "DKIMStatus": "Error",
      "SPFErrors": [],
      "SPFRecordsCurrentValues": ["v=spf1 include:spf.mailjet.com -all"],
      "SPFStatus": "OK"
    }
  ],
  "Total": 1
}
```

To check the configuration of a given domain, issue a `POST` request on [`dns/:id/check`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/#v3_post_dns_dns_ID_check) resource. This action checks if the DNS configuration for SPF and DKIM records matches the expected configuration from Mailjet.

## Verify-Domain

Info
Maps to /senders/verify-domain.json

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$response = $mj->post(Resources::$SenderValidate, ['id' => $id]);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# Validate : check if the Ownership token has been properly setup on the website or DNS
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/sender/$ID/validate \
	-H 'Content-Type: application/json' \
	-d '{
	}'
```

Node.js
```javascript
/**
 *
 * Validate : check if the Ownership token has been properly setup on the website or DNS
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet
  .post('sender')
  .id($ID)
  .action('validate')
  .request()
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# Validate : check if the Ownership token has been properly setup on the website or DNS
Mailjet.configure do |config|
  config.api_key = ENV['MJ_APIKEY_PUBLIC']
  config.secret_key = ENV['MJ_APIKEY_PRIVATE']
  config.default_from = 'your default sending address'
end
variable = Mailjet::Sender_validate.create(id: $ID)
```

Python
```python
"""
Validate : check if the Ownership token has been properly setup on the website or DNS
"""
from mailjet_rest import Client
import os
api_key = os.environ['MJ_APIKEY_PUBLIC']
api_secret = os.environ['MJ_APIKEY_PRIVATE']
mailjet = Client(auth=(api_key, api_secret))
id = '$ID'
result = mailjet.sender_validate.create(id=id)
print result.status_code
print result.json()
```

Go
```go
/*
Validate : check if the Ownership token has been properly setup on the website or DNS
*/
package main
import (
	"fmt"
	. "github.com/mailjet/mailjet-apiv3-go"
	"github.com/mailjet/mailjet-apiv3-go/resources"
	"os"
)
func main () {
	mailjetClient := NewMailjetClient(os.Getenv("MJ_APIKEY_PUBLIC"), os.Getenv("MJ_APIKEY_PRIVATE"))
	var data []resources.SenderValidate
	mr := &MailjetRequest{
	  Resource: "sender",
	  ID: RESOURCE_ID,
	  Action: "validate",
	}
	fmr := &FullMailjetRequest{
	  Info: mr,
	  Payload: &resources.SenderValidate {
    },
	}
	err := mailjetClient.Post(fmr, &data)
	if err != nil {
	  fmt.Println(err)
	}
	fmt.Printf("Data array: %+v\n", data)
}
```

Java
```java
package com.my.project;
import com.mailjet.client.errors.MailjetException;
import com.mailjet.client.MailjetClient;
import com.mailjet.client.MailjetRequest;
import com.mailjet.client.MailjetResponse;
import com.mailjet.client.resource.SenderValidate;
public class MyClass {
    /**
     * Validate : check if the Ownership token has been properly setup on the website or DNS
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(SenderValidate.resource, ID);
      response = client.post(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

```json
{
  "Count": 1,
  "Data": [
    {
      "Errors": {
        "DNSValidationError": " DNS record verification failed as no TXT record for that ownership token was found on the remote server.",
        "FileValidationError": " File verification failed as ecff63dc3593b2323b5ab3d7d823c103.txt cannot be found at domain root."
      },
      "GlobalError": "Neither the file at your domain root nor the DNS TXT record have been found to validate this sender.",
      "ValidationMethod": ""
    }
  ],
  "Total": 1
}
```

Once you cleared out your DNS configuration, you can validate the related [`sender`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/#v3_post_sender_sender_ID_validate).

## Info

Info
Maps to /senders/info.json

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$response = $mj->get(Resources::$Sender);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
curl -s \
	-X GET \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/sender
```

Node.js
```javascript
/**
 *
 * View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet.get('sender').request()
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
Mailjet.configure do |config|
  config.api_key = ENV['MJ_APIKEY_PUBLIC']
  config.secret_key = ENV['MJ_APIKEY_PRIVATE']
  config.default_from = 'your default sending address'
end
variable = Mailjet::Sender.all()
```

Python
```python
"""
View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
"""
from mailjet_rest import Client
import os
api_key = os.environ['MJ_APIKEY_PUBLIC']
api_secret = os.environ['MJ_APIKEY_PRIVATE']
mailjet = Client(auth=(api_key, api_secret))
result = mailjet.sender.get()
print result.status_code
print result.json()
```

Go
```go
/*
View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
*/
package main
import (
	"fmt"
	. "github.com/mailjet/mailjet-apiv3-go"
	"github.com/mailjet/mailjet-apiv3-go/resources"
	"os"
)
func main () {
	mailjetClient := NewMailjetClient(os.Getenv("MJ_APIKEY_PUBLIC"), os.Getenv("MJ_APIKEY_PRIVATE"))
	var data []resources.Sender
	_, _, err := mailjetClient.List("sender", &data)
	if err != nil {
	  fmt.Println(err)
	}
	fmt.Printf("Data array: %+v\n", data)
}
```

Java
```java
package com.my.project;
import com.mailjet.client.errors.MailjetException;
import com.mailjet.client.MailjetClient;
import com.mailjet.client.MailjetRequest;
import com.mailjet.client.MailjetResponse;
import com.mailjet.client.resource.Sender;
public class MyClass {
    /**
     * View : Manage an email sender for a single API key. An e-mail address or a complete domain (*) has to be registered and validated before being used to send e-mails. In order to manage a sender available across multiple API keys, see the related MetaSender resource.
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(Sender.resource);
      response = client.get(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

```json
{
  "Count": 1,
  "Data": [
    {
      "CreatedAt": "2015-09-07T06:59:52Z",
      "DNSID": "1",
      "Email": "anothersender@example.com",
      "EmailType": "unknown",
      "Filename": "0123456789abcdef.txt",
      "ID": "1",
      "IsDefaultSender": "false",
      "Name": "Myname",
      "Status": "Inactive"
    }
  ],
  "Total": 1
}
```

Issue a `GET` request to the [`sender`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/#v3_get_sender_sender_ID) resource with the associated ID.

## Time-Series

Info
Maps to /senders/time-series.json

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$response = $mj->get(Resources::$Senderstatistics);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# View : API Key sender email address message/open/click statistical information.
curl -s \
	-X GET \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/senderstatistics
```

Node.js
```javascript
/**
 *
 * View : API Key sender email address message/open/click statistical information.
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet.get('senderstatistics').request()
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# View : API Key sender email address message/open/click statistical information.
Mailjet.configure do |config|
  config.api_key = ENV['MJ_APIKEY_PUBLIC']
  config.secret_key = ENV['MJ_APIKEY_PRIVATE']
  config.default_from = 'your default sending address'
end
variable = Mailjet::Senderstatistics.all()
```

Python
```python
"""
View : API Key sender email address message/open/click statistical information.
"""
from mailjet_rest import Client
import os
api_key = os.environ['MJ_APIKEY_PUBLIC']
api_secret = os.environ['MJ_APIKEY_PRIVATE']
mailjet = Client(auth=(api_key, api_secret))
result = mailjet.senderstatistics.get()
print result.status_code
print result.json()
```

Go
```go
/*
View : API Key sender email address message/open/click statistical information.
*/
package main
import (
	"fmt"
	. "github.com/mailjet/mailjet-apiv3-go"
	"github.com/mailjet/mailjet-apiv3-go/resources"
	"os"
)
func main () {
	mailjetClient := NewMailjetClient(os.Getenv("MJ_APIKEY_PUBLIC"), os.Getenv("MJ_APIKEY_PRIVATE"))
	var data []resources.Senderstatistics
	_, _, err := mailjetClient.List("senderstatistics", &data)
	if err != nil {
	  fmt.Println(err)
	}
	fmt.Printf("Data array: %+v\n", data)
}
```

Java
```java
package com.my.project;
import com.mailjet.client.errors.MailjetException;
import com.mailjet.client.MailjetClient;
import com.mailjet.client.MailjetRequest;
import com.mailjet.client.MailjetResponse;
import com.mailjet.client.resource.Senderstatistics;
public class MyClass {
    /**
     * View : API Key sender email address message/open/click statistical information.
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(Senderstatistics.resource);
      response = client.get(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

```json
{
  "Count": 1,
  "Data": [
    {
      "BlockedCount": "",
      "BouncedCount": "",
      "ClickedCount": "",
      "DeliveredCount": "",
      "LastActivityAt": "",
      "OpenedCount": "",
      "ProcessedCount": "",
      "QueuedCount": "",
      "SenderID": "",
      "SpamComplaintCount": "",
      "UnsubscribedCount": ""
    }
  ],
  "Total": 1
}
```

Use the [`statcounters`](/docs/api-reference/email-api/categories/statistics/#v3_get_statcounters) resource to retrieve all the main information you need. To get sender stats, make sure to set the value of the `CounterSource` filter to `Sender` and the `SourceID` filter to the respective sender ID.