# Use a sender on all API Keys (metasender)

By default your senders are not shared between the primary and sub-account API keys. In case you want to use the same sender / domain on all your API keys, you should create a metasender.

Do a POST /metasender to create a new metasender object.

### Example

cURL
```shell
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/metasender \
	-H 'Content-Type: application/json' \
	-d '{
      "Description":"Metasender 1 - used for Promo emails",
      "Email":"pilot@mailjet.com"
	}'
```

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'),true,['version' => 'v3']);
$body = [
  'Description' => "Metasender 1 - used for Promo emails",
  'Email' => "pilot@mailjet.com"
];
$response = $mj->post(Resources::$Metasender, ['body' => $body]);
$response->success() && var_dump($response->getData());
?>
```

Node.js
```javascript
const mailjet = require ('node-mailjet')
	.connect(process.env.MJ_APIKEY_PUBLIC, process.env.MJ_APIKEY_PRIVATE)
const request = mailjet
	.post("metasender", {'version': 'v3'})
	.request({
      "Description":"Metasender 1 - used for Promo emails",
      "Email":"pilot@mailjet.com"
    })
request
	.then((result) => {
		console.log(result.body)
	})
	.catch((err) => {
		console.log(err.statusCode)
	})
```

Ruby
```ruby
require 'mailjet'
Mailjet.configure do |config|
  config.api_key = ENV['MJ_APIKEY_PUBLIC']
  config.secret_key = ENV['MJ_APIKEY_PRIVATE']
  config.api_version = "v3"
end
variable = Mailjet::Metasender.create(
  description: "Metasender 1 - used for Promo emails",
  email: "pilot@mailjet.com"
)
p variable.attributes['Data']
```

Python
```python
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), version='v3')
data = {
  'Description': "Metasender 1 - used for Promo emails",
  'Email': "pilot@mailjet.com"
}
result = mailjet.metasender.create(data=data)
print result.status_code
print result.json()
```

Java
```java
package com.my.project;
import com.mailjet.client.errors.MailjetException;
import com.mailjet.client.errors.MailjetSocketTimeoutException;
import com.mailjet.client.MailjetClient;
import com.mailjet.client.MailjetRequest;
import com.mailjet.client.MailjetResponse;
import com.mailjet.client.ClientOptions;
import com.mailjet.client.resource.Metasender;
import org.json.JSONArray;
import org.json.JSONObject;
public class MyClass {
    public static void main(String[] args) throws MailjetException, MailjetSocketTimeoutException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient(System.getenv("MJ_APIKEY_PUBLIC"), System.getenv("MJ_APIKEY_PRIVATE"), new ClientOptions("v3"));
      request = new MailjetRequest(Metasender.resource)
            .property(Metasender.DESCRIPTION, "Metasender 1 - used for Promo emails")
            .property(Metasender.EMAIL, "pilot@mailjet.com")
      );
      response = client.post(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

Go
```go
package main
import (
	"fmt"
	"log"
	"os"
	mailjet "github.com/mailjet/mailjet-apiv3-go"
	"github.com/mailjet/mailjet-apiv3-go/resources"
)
func main () {
	mailjetClient := NewMailjetClient(os.Getenv("MJ_APIKEY_PUBLIC"), os.Getenv("MJ_APIKEY_PRIVATE"))
	var data []resources.Metasender
	mr := &Request{
	  Resource: "metasender",
	}
	fmr := &FullRequest{
	  Info: mr,
	  Payload: &resources.Metasender { 
	  Description:"Metasender 1 - used for Promo emails",
	  Email:"pilot@mailjet.com"
      }
	}
	err := mailjetClient.Post(fmr, &data)
	if err != nil {
	  fmt.Println(err)
	}
	fmt.Printf("Data array: %+v\n", data)
}
```

C#
```csharp
using Mailjet.Client;
using Mailjet.Client.Resources;
using System;
using Newtonsoft.Json.Linq;
namespace Mailjet.ConsoleApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         RunAsync().Wait();
      }
      static async Task RunAsync()
      {
         MailjetClient client = new MailjetClient(Environment.GetEnvironmentVariable("MJ_APIKEY_PUBLIC"), Environment.GetEnvironmentVariable("MJ_APIKEY_PRIVATE"))
         {
            Version = ApiVersion.V3,
         };
         MailjetRequest request = new MailjetRequest
         {
            Resource = Metasender.Resource,
         }
             .Property(Metasender.Description, "Metasender 1 - used for Promo emails")
             .Property(Metasender.Email, "pilot@mailjet.com");
         MailjetResponse response = await client.PostAsync(request);
         if (response.IsSuccessStatusCode)
         {
            Console.WriteLine(string.Format("Total: {0}, Count: {1}\n", response.GetTotal(), response.GetCount()));
            Console.WriteLine(response.GetData());
         }
         else
         {
            Console.WriteLine(string.Format("StatusCode: {0}\n", response.StatusCode));
            Console.WriteLine(string.Format("ErrorInfo: {0}\n", response.GetErrorInfo()));
            Console.WriteLine(response.GetData());
            Console.WriteLine(string.Format("ErrorMessage: {0}\n", response.GetErrorMessage()));
         }
      }
   }
}
```

### API Response

```
{
	"Count": 1,
	"Data": [
		{
			"Description": "Metasender 1 - used for Promo emails",
			"CreatedAt": "2018-01-01T00:00:00",
			"Email": "pilot@mailjet.com",
			"Filename": "a12345b67c123456ab1ca12345b1234b5.txt",
			"ID": 123,
			"IsEnabled": true
		}
	],
	"Total": 1
}
```

Afterwards you need to request the validation of the metasender by our support team. Once done, it will be authorized for use on all of your API keys and any additional senders matching this metasender will also be validated.