# Single Contact Management

## Create a contact

You can create new contacts with a `POST` request on the contact resource.

### Example

cURL
```shell
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/contact \
	-H 'Content-Type: application/json' \
	-d '{
      "IsExcludedFromCampaigns":"true",
      "Name":"New Contact",
      "Email":"passenger@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 = [
  'IsExcludedFromCampaigns' => "true",
  'Name' => "New Contact",
  'Email' => "passenger@mailjet.com"
];
$response = $mj->post(Resources::$Contact, ['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("contact", {'version': 'v3'})
	.request({
      "IsExcludedFromCampaigns":"true",
      "Name":"New Contact",
      "Email":"passenger@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::Contact.create(
  is_excluded_from_campaigns: "true",
  name: "New Contact",
  email: "passenger@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 = {
  'IsExcludedFromCampaigns': "true",
  'Name': "New Contact",
  'Email': "passenger@mailjet.com"
}
result = mailjet.contact.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.Contact;
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(Contact.resource)
            .property(Contact.ISEXCLUDEDFROMCAMPAIGNS, "true")
            .property(Contact.NAME, "New Contact")
            .property(Contact.EMAIL, "passenger@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.Contact
	mr := &Request{
	  Resource: "contact",
	}
	fmr := &FullRequest{
	  Info: mr,
	  Payload: &resources.Contact { 
	  IsExcludedFromCampaigns:"true",
	  Name:"New Contact",
	  Email:"passenger@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 = Contact.Resource,
         }
             .Property(Contact.IsExcludedFromCampaigns, "true")
             .Property(Contact.Name, "New Contact")
             .Property(Contact.Email, "passenger@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": [
		{
			"IsExcludedFromCampaigns": true,
			"Name": "New Contact",
			"CreatedAt": "2018-01-01T00:00:00",
			"DeliveredCount": 10,
			"Email": "passenger@mailjet.com",
			"ExclusionFromCampaignsUpdatedAt": "2018-01-01T00:00:00",
			"ID": 123456789,
			"IsOptInPending": false,
			"IsSpamComplaining": false,
			"LastActivityAt": "2018-01-01T00:00:00",
			"LastUpdateAt": "2018-01-01T00:00:00",
			"UnsubscribedAt": "2018-01-01T00:00:00",
			"UnsubscribedBy": "2018-01-01T00:00:00"
		}
	],
	"Total": 1
}
```

## Manage Contact Properties

If you want to add more granular details about your contacts, Mailjet provides the capability to add custom data to contacts. This additional data can help you personalize the emails you are sending, and allows you to target specific sections of your customers using segmentation.

The addition of custom data starts with the definition of the extra information to store with the contacts (It could be for example the country the contacts live in, how old the contacts are, their current income, the value of their purchases on your site...) and how this data will be stored (string, number, boolean...).

To define custom contact data, perform a `POST` on `/contactmetadata` with the following properties:

`Name` : the name of the custom data field
`DataType` : the type of data that is being stored (this can be either a str, int, float, datetime or bool)
`NameSpace` : this can be either `static` or `historic` (legacy)

Info
Keep in mind that the accepted formats for a `datetime` data type are Unix timestamp `(e.g. 1514764800)`and RFC3339 (e.g. `2018-01-01T00:00:00`)

### Example

cURL
```shell
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/contactmetadata \
	-H 'Content-Type: application/json' \
	-d '{
      "Datatype":"str",
      "Name":"first_name",
      "NameSpace":"static"
	}'
```

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 = [
  'Datatype' => "str",
  'Name' => "first_name",
  'NameSpace' => "static"
];
$response = $mj->post(Resources::$Contactmetadata, ['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("contactmetadata", {'version': 'v3'})
	.request({
      "Datatype":"str",
      "Name":"first_name",
      "NameSpace":"static"
    })
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::Contactmetadata.create(
  datatype: "str",
  name: "first_name",
  name_space: "static"
)
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 = {
  'Datatype': "str",
  'Name': "first_name",
  'NameSpace': "static"
}
result = mailjet.contactmetadata.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.Contactmetadata;
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(Contactmetadata.resource)
            .property(Contactmetadata.DATATYPE, "str")
            .property(Contactmetadata.NAME, "first_name")
            .property(Contactmetadata.NAMESPACE, "static")
      );
      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.Contactmetadata
	mr := &Request{
	  Resource: "contactmetadata",
	}
	fmr := &FullRequest{
	  Info: mr,
	  Payload: &resources.Contactmetadata { 
	  Datatype:"str",
	  Name:"first_name",
	  NameSpace:"static"
      }
	}
	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 = Contactmetadata.Resource,
         }
             .Property(Contactmetadata.Datatype, "str")
             .Property(Contactmetadata.Name, "first_name")
             .Property(Contactmetadata.NameSpace, "static");
         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": [
		{
			"Datatype": "str",
			"ID": 4321,
			"Name": "first_name",
			"NameSpace": "static"
		}
	],
	"Total": 1
}
```

To add, edit or update the data saved for a specific contact, do a `PUT` request on `/contactdata/{contact_ID or contact_email}`.

### Example

cURL
```shell
curl -s \
	-X PUT \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/contactdata/$contact_ID \
	-H 'Content-Type: application/json' \
	-d '{
      "Data":[
        {
          "Name":"first_name",
          "Value":"John"
        }
      ]
	}'
```

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 = [
  'Data' => [
    [
      'Name' => "first_name",
      'Value' => "John"
    ]
  ]
];
$response = $mj->put(Resources::$Contactdata, ['id' => $id, '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
	.put("contactdata", {'version': 'v3'})
	.id($contact_ID)
	.request({
      "Data":[
        {
          "Name":"first_name",
          "Value":"John"
        }
      ]
    })
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
target = Mailjet::Contactdata.find($contact_ID)
target.update_attributes(
  data: [
    {
      'name' => "first_name",
      'value' => "John"
    }
  ]
)
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')
id = '$contact_ID'
data = {
  'Data': [
    {
      "Name": "first_name",
      "Value": "John"
    }
  ]
}
result = mailjet.contactdata.update(id=id, 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.Contactdata;
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(Contactdata.resource, ID)
            .property(Contactdata.DATA, new JSONArray()
                .put(new JSONObject()
                    .put("Name", "first_name")
                    .put("Value", "John")
                )
            )
      );
      response = client.put(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"))
	mr := &Request{
	  Resource: "contactdata",
	  ID: RESOURCE_ID,
	}
	fmr := &FullRequest{
	  Info: mr,
	  Payload: &resources.Contactdata { 
      Data: []MailjetDat {
          MailjetDat {
            Name:"first_name",
            Value:"John"
          }
        }
      }
	}
	err := mailjetClient.Put(fmr)
	if err != nil {
	  fmt.Println(err)
	}
}
```

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 = Contactdata.Resource,
            ResourceId = ResourceId.Numeric(ID)
         }
             .Property(Contactdata.Data, new JArray {
                 new JObject {
                     {"Name", "first_name"},
                     {"Value", "John"}
                 }
             });
         MailjetResponse response = await client.PutAsync(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": [
		{
			"Data": [
				{}
			],
			"ContactID": 123456,
			"ID": 123456
		}
	],
	"Total": 1
}
```

Contact data can also be added for multiple contacts at the same time by using the bulk contact management resources.

## Create a contact list

Contact lists are created with `POST` request on the `/contactslist`

### Example

cURL
```shell
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/contactslist \
	-H 'Content-Type: application/json' \
	-d '{
      "Name":"my_contactslist"
	}'
```

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 = [
  'Name' => "my_contactslist"
];
$response = $mj->post(Resources::$Contactslist, ['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("contactslist", {'version': 'v3'})
	.request({
      "Name":"my_contactslist"
    })
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::Contactslist.create(
  name: "my_contactslist"
)
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 = {
  'Name': "my_contactslist"
}
result = mailjet.contactslist.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.Contactslist;
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(Contactslist.resource)
            .property(Contactslist.NAME, "my_contactslist")
      );
      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.Contactslist
	mr := &Request{
	  Resource: "contactslist",
	}
	fmr := &FullRequest{
	  Info: mr,
	  Payload: &resources.Contactslist { 
	  Name:"my_contactslist"
      }
	}
	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 = Contactslist.Resource,
         }
             .Property(Contactslist.Name, "my_contactslist");
         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": [
		{
			"Name": "my_contactslist",
			"Address": "abcdef123",
			"CreatedAt": "2018-01-01T00:00:00",
			"ID": 123456,
			"SubscriberCount": 111
		}
	],
	"Total": 1
}
```

## Add a contact to a contact list

To add a contact to a list, you need to create a new list recipient with a `POST` request on the `/listrecipient` resource. You can specify the contact by either providing the `contact ID` (in ContactID) or email address (in `ContactAlt`), as well as the list with either the list ID (in `ListID`) or the list name (in `ListAlt`).

### Example

cURL
```shell
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/listrecipient \
	-H 'Content-Type: application/json' \
	-d '{
      "IsUnsubscribed":"true",
      "ContactID":"987654321",
      "ContactAlt":"passenger@mailjet.com",
      "ListID":"123456",
      "ListAlt":"abcdef123"
	}'
```

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 = [
  'IsUnsubscribed' => "true",
  'ContactID' => "987654321",
  'ContactAlt' => "passenger@mailjet.com",
  'ListID' => "123456",
  'ListAlt' => "abcdef123"
];
$response = $mj->post(Resources::$Listrecipient, ['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("listrecipient", {'version': 'v3'})
	.request({
      "IsUnsubscribed":"true",
      "ContactID":"987654321",
      "ContactAlt":"passenger@mailjet.com",
      "ListID":"123456",
      "ListAlt":"abcdef123"
    })
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::Listrecipient.create(
  is_unsubscribed: "true",
  contact_id: "987654321",
  contact_alt: "passenger@mailjet.com",
  list_id: "123456",
  list_alt: "abcdef123"
)
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 = {
  'IsUnsubscribed': "true",
  'ContactID': "987654321",
  'ContactAlt': "passenger@mailjet.com",
  'ListID': "123456",
  'ListAlt': "abcdef123"
}
result = mailjet.listrecipient.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.Listrecipient;
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(Listrecipient.resource)
            .property(Listrecipient.ISUNSUBSCRIBED, "true")
            .property(Listrecipient.CONTACTID, "987654321")
            .property(Listrecipient.CONTACTALT, "passenger@mailjet.com")
            .property(Listrecipient.LISTID, "123456")
            .property(Listrecipient.LISTALT, "abcdef123")
      );
      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.Listrecipient
	mr := &Request{
	  Resource: "listrecipient",
	}
	fmr := &FullRequest{
	  Info: mr,
	  Payload: &resources.Listrecipient { 
	  IsUnsubscribed:"true",
	  ContactID:"987654321",
	  ContactAlt:"passenger@mailjet.com",
	  ListID:"123456",
	  ListAlt:"abcdef123"
      }
	}
	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 = Listrecipient.Resource,
         }
             .Property(Listrecipient.IsUnsubscribed, "true")
             .Property(Listrecipient.ContactID, "987654321")
             .Property(Listrecipient.ContactAlt, "passenger@mailjet.com")
             .Property(Listrecipient.ListID, "123456")
             .Property(Listrecipient.ListAlt, "abcdef123");
         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": [
		{
			"IsUnsubscribed": true,
			"ContactID": 987654321,
			"ID": 1234567890,
			"IsActive": true,
			"ListID": 123456,
			"ListName": "abcdef123",
			"SubscribedAt": "2018-01-01T00:00:00",
			"UnsubscribedAt": "2018-01-01T00:00:00"
		}
	],
	"Total": 1
}
```