# Manage contacts via CSV Upload

## Using a CSV file to upload

To do a CSV upload, you need to complete the following three steps:

1. Create the CSV content in a format compatible with the Mailjet API.
2. Upload the CSV content to a Mailjet server via an API call.
3. Import the CSV file using the `/csvimport` content


## CSV content requirements

The first row must include the names of the different properties included in the CSV - e.g. "email", "first_name", "age". If there is no `/contactmetadata` object with the respective property name, if will be created automatically by the API with `DataType: string`.

The data for each contact should be included on a new line.

### Examples

```
"email","age"
"foo@example.org",42
"bar@example.com",13
"sam@ple.co.uk",37
```

Info
If the CSV includes `datetime` contact properties, you should NOT include the property names in the first row. Instead, they should be specified using the `ImportOptions` property in the `POST /csvimport` payloa

### Example

```
"foo@example.org",2018/10/12
"bar@example.com",2016/10/12
"sam@ple.co.uk",2017/10/12
```

## Upload the CSV

To upload the CSV you need to specify the target contact list ID and, of course, the CSV content.

### Example

cURL
```shell
# Import the CSV file through the DATA API
curl -s \
-X POST \
--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
https://api.mailjet.com/v3/DATA/contactslist/$ID_CONTACTLIST/CSVData/text:plain \
-H "Content-Type: text/plain" \
--data-binary "@./test.csv"
```

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
// View: CSV upload
$CSVContent = file_get_contents('./test.csv');
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$response = $mj->post(Resources::$ContactslistCsvdata, ['body' => $CSVContent, 'id' => $ID_CONTACTLIST]);
$response->success() && var_dump($response->getData());
?>
```

Node.js
```javascript
const fs = require ('fs')
const mailjet = require ('node-mailjet')
    .connect(process.env.MJ_APIKEY_PUBLIC, process.env.MJ_APIKEY_PRIVATE)
fs.readFile('./data.csv', (err, data) => {
  if (err) { return console.error(err) }
  const request = mailjet.post('contactslist')
      .id("$ID_CONTACTLIST")
      .action('csvdata')
      .request(data);
  request
  .then(result => {
    console.log(result.body)
  })
  .catch(error => {
    console.log(error.statusCode)
  })
})
```

Ruby
```ruby
# unsupported at the moment, please refer to cURL
```

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))
f = open('./data.csv')
result = mailjet.contactslist_csvdata.create(id='$ID_CONTACTLIST', data=f.read())
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.resource.Csvimport;
import org.json.JSONArray;
import org.json.JSONObject;
public class MyClass {
    /**
     * Modify : A wrapper for the CSV importer
     */
    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"));
      request = new MailjetRequest(Csvimport.resource, ID)
        .property(Csvimport.DATA, MYFILE);
      response = client.put(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

Go
```go
package main
import (
    "fmt"
    "io/ioutil"
    . "github.com/mailjet/mailjet-apiv3-go"
    "os"
)
func check(e error) {
    if e != nil {
        panic(e)
    }
}
func main () {
    dat, err := ioutil.ReadFile("./data.csv")
    check(err)
    mailjetClient := NewMailjetClient(os.Getenv("MJ_APIKEY_PUBLIC"), os.Getenv("MJ_APIKEY_PRIVATE"))
    type MyStruct struct {
	   ID int
    }
    var data = new(MyStruct)
    mr := &DataRequest{
      SourceType: "contactslist",
      SourceTypeID: "$ID_CONTACTLIST",
      DataType: "CSVData",
      MimeType: "text:plain",
    }
    fmr := &FullDataRequest{
      Info: mr,
      Payload: string(dat),
    }
    err1 := mailjetClient.PostData(fmr, &data)
    if err1 != nil {
      fmt.Println(err1)
    }
    fmt.Printf("Data array: %+v\n", data)
}
```

C#
```csharp
# unsupported at the moment, please refer to cURL
```

Save the ID - it’s used to specify the Data ID during `POST /csvimport`.

## Import CSV content to a list

You now need to use the uploaded data to manage the contacts in a specific contact list using the /csvimport resource.

The actions you can perform are:

- `addforce `: Add the contacts to the list and subscribe all of them. If the contact is already present in the list as unsubscribed, it will be forcibly subscribed once again.
- `addnoforce` : Add the contacts to the list and subscribe them to it. If the contact is already present, it will retain its subscription status, i.e. if a contact is part of the list, but unsubscribed, it will not be forcibly subscribed again.
- `remove` : Remove the contacts from the list
- `unsub`: Unsubscribe the contacts from the list


Select the action / method, the list ID and the data ID in the payload:

### Example

cURL
```shell
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/csvimport \
	-H 'Content-Type: application/json' \
	-d '{
      "ErrTreshold":"1",
      "ImportOptions":"",
      "Method":"addnoforce",
      "ContactsListID":"123456",
      "DataID":"98765432123456789"
	}'
```

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 = [
  'ErrTreshold' => "1",
  'ImportOptions' => "",
  'Method' => "addnoforce",
  'ContactsListID' => "123456",
  'DataID' => "98765432123456789"
];
$response = $mj->post(Resources::$Csvimport, ['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("csvimport", {'version': 'v3'})
	.request({
      "ErrTreshold":"1",
      "ImportOptions":"",
      "Method":"addnoforce",
      "ContactsListID":"123456",
      "DataID":"98765432123456789"
    })
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::Csvimport.create(
  err_treshold: "1",
  import_options: "",
  method: "addnoforce",
  contacts_list_id: "123456",
  data_id: "98765432123456789"
)
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 = {
  'ErrTreshold': "1",
  'ImportOptions': "",
  'Method': "addnoforce",
  'ContactsListID': "123456",
  'DataID': "98765432123456789"
}
result = mailjet.csvimport.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.Csvimport;
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(Csvimport.resource)
            .property(Csvimport.ERRTRESHOLD, "1")
            .property(Csvimport.IMPORTOPTIONS, )
            .property(Csvimport.METHOD, "addnoforce")
            .property(Csvimport.CONTACTSLISTID, "123456")
            .property(Csvimport.DATAID, "98765432123456789")
      );
      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.Csvimport
	mr := &Request{
	  Resource: "csvimport",
	}
	fmr := &FullRequest{
	  Info: mr,
	  Payload: &resources.Csvimport { 
	  ErrTreshold:"1",
	  ImportOptions:"",
	  Method:"addnoforce",
	  ContactsListID:"123456",
	  DataID:"98765432123456789"
      }
	}
	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 = Csvimport.Resource,
         }
             .Property(Csvimport.ErrTreshold, "1")
             .Property(Csvimport.ImportOptions, )
             .Property(Csvimport.Method, "addnoforce")
             .Property(Csvimport.ContactsListID, "123456")
             .Property(Csvimport.DataID, "98765432123456789");
         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": [
		{
			"ErrTreshold": 1,
			"ImportOptions": "",
			"Method": "addnoforce",
			"AliveAt": "2018-01-01T00:00:00",
			"ContactsListID": 123456,
			"Count": 12,
			"Current": 10,
			"DataID": 98765432123456780,
			"Errcount": 0,
			"ID": 987654,
			"JobEnd": "2018-01-01T00:00:00",
			"JobStart": "2018-01-01T00:00:00",
			"RequestAt": "2018-01-01T00:00:00",
			"Status": "Upload"
		}
	],
	"Total": 1
}
```

The ID returned is the ID of the import job - use it to `monitor the import progress`.

### Using CSV with Datetime contact data

When trying to import contact data with type datetime, you should define an additional property in the payload - ImportOptions. Its value should be passed as a string, containing the following options:

- `DateTimeFormat` : it shows the format of the datetime in the CSV file. It can be represented as any combination of the acronyms for year (yy), month (mm), day (dd), hour (hh), minute (nn), second (ss). The date is separated from the time with an empty space. The separators for the dates could be a dash(-), slash (/) or dot (.). The separator for the time is a colon (:). The RFC3339 format is also supported (e.g. 'yyyy-mm-ddThh:nn:ss+01:00').
- `TimezoneOffset` : used to select timezone offset. The value is an integer in the -12 to 12 range.
- `FieldNames` : specifies the names of the fields that are going to be imported. This corresponds to the first row of the CSV, when you import contacts without datetime contact data. All properties that will be modified should be added to the import options, following the exact same order as the columns in the CSV.


### Example

cURL
```shell
# Create: A wrapper for the CSV importer
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/csvimport \
	-H 'Content-Type: application/json' \
	-d '{
		"ContactsListID":"$ID_CONTACTLIST",
		"DataID":"$ID_DATA",
		"Method":"addnoforce",
		"ImportOptions":"{\"DateTimeFormat\": \"yyyy/mm/dd\",\"TimezoneOffset\": 2,\"FieldNames\": [\"email\",\"birthday\"]}"
	}'
```

PHP
```php
<?php
/*
Create: A wrapper for the CSV importer
*/
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$body = [
    'ContactsListID' => "$ID_CONTACTLIST",
    'DataID' => "$ID_DATA",
    'Method' => "addnoforce",
    'ImportOptions' => "{\\"DateTimeFormat\\": \\"yyyy/mm/dd\\",\\"TimezoneOffset\\": 2,\\"FieldNames\\": [\\"email\\",\\"birthday\\"]}"
];
$response = $mj->post(Resources::$Csvimport, ['body' => $body]);
$response->success() && var_dump($response->getData());
?>
```

Node.js
```javascript
/**
 *
 * Create: A wrapper for the CSV importer
 *
 */
const mailjet = require ('node-mailjet')
	.connect(process.env.MJ_APIKEY_PUBLIC, process.env.MJ_APIKEY_PRIVATE)
const request = mailjet
	.post("csvimport")
	.request({
		"ContactsListID":"$ID_CONTACTLIST",
		"DataID":"$ID_DATA",
		"Method":"addnoforce",
		"ImportOptions":"{\"DateTimeFormat\": \"yyyy/mm/dd\",\"TimezoneOffset\": 2,\"FieldNames\": [\"email\",\"birthday\"]}"
	})
request
	.then((result) => {
		console.log(result.body)
	})
	.catch((err) => {
		console.log(err.statusCode)
	})
```

Ruby
```ruby
# Create: A wrapper for the CSV importer
require 'mailjet'
Mailjet.configure do |config|
  config.api_key = ENV['MJ_APIKEY_PUBLIC']
  config.secret_key = ENV['MJ_APIKEY_PRIVATE']  
end
variable = Mailjet::Csvimport.create(contacts_list_id: "$ID_CONTACTLIST",
data_id: "$ID_DATA",
method: "addnoforce",
import_options: "{\"DateTimeFormat\": \"yyyy/mm/dd\",\"TimezoneOffset\": 2,\"FieldNames\": [\"email\",\"birthday\"]}"
)
p variable.attributes['Data']
```

Python
```python
"""
Create: A wrapper for the CSV importer
"""
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))
data = {
  'ContactsListID': '$ID_CONTACTLIST',
  'DataID': '$ID_DATA',
  'Method': 'addnoforce',
  'ImportOptions': '{\"DateTimeFormat\": \"yyyy/mm/dd\",\"TimezoneOffset\": 2,\"FieldNames\": [\"email\",\"birthday\"]}'
}
result = mailjet.csvimport.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.resource.Csvimport;
import org.json.JSONArray;
import org.json.JSONObject;
public class MyClass {
    /**
     * Create: A wrapper for the CSV importer
     */
    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"));
      request = new MailjetRequest(Csvimport.resource)
			.property(Csvimport.CONTACTSLISTID, "$ID_CONTACTLIST")
			.property(Csvimport.DATAID, "$ID_DATA")
			.property(Csvimport.METHOD, "addnoforce")
			.property(Csvimport.IMPORTOPTIONS, "{\\"DateTimeFormat\\": \\"yyyy/mm/dd\\",\\"TimezoneOffset\\": 2,\\"FieldNames\\": [\\"email\\",\\"birthday\\"]}");
      response = client.post(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

Go
```go
/*
Create: A wrapper for the CSV importer
*/
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.Csvimport
	mr := &Request{
	  Resource: "csvimport",
	}
	fmr := &FullRequest{
	  Info: mr,
	  Payload: &resources.Csvimport {
      ContactsListID: "$ID_CONTACTLIST",
      DataID: "$ID_DATA",
      Method: "addnoforce",
    ImportOptions: "{\"DateTimeFormat\": \"yyyy/mm/dd\",\"TimezoneOffset\": 2,\"FieldNames\": [\"email\",\"birthday\"]}",
    },
	}
	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
   {
      /// <summary>
      /// Create: A wrapper for the CSV importer
      /// </summary>
      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"));
         MailjetRequest request = new MailjetRequest
         {
            Resource = Csvimport.Resource,
         }
            .Property(Csvimport.ContactsListID, "$ID_CONTACTLIST")
            .Property(Csvimport.DataID, "$ID_DATA")
            .Property(Csvimport.Method, "addnoforce")
            .Property(Csvimport.ImportOptions, "{\\"DateTimeFormat\\": \\"yyyy/mm/dd\\",\\"TimezoneOffset\\": 2,\\"FieldNames\\": [\\"email\\",\\"birthday\\"]}");
         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()));
         }
      }
   }
}
```

## Monitor the Import Progress

You can now make sure the task is completed successfully. You might need multiple checks as a huge amount of data may take some time to be processed (several hours are not uncommon). Using the `JobID` returned in the previous step, you can retrieve the job status.

### Example

cURL
```shell
curl -s \
	-X GET \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/csvimport/$importjob_ID \
```

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']);
$response = $mj->get(Resources::$Csvimport, ['id' => $id]);
$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
	.get("csvimport", {'version': 'v3'})
	.id($importjob_ID)
	.request()
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::Csvimport.find($importjob_ID
)
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 = '$importjob_ID'
result = mailjet.csvimport.get(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.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.Csvimport;
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(Csvimport.resource, ID);
      response = client.get(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.Csvimport
	mr := &Request{
	  Resource: "csvimport",
	  ID: RESOURCE_ID,
	}
	err := mailjetClient.Get(mr, &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 = Csvimport.Resource,
            ResourceId = ResourceId.Numeric(ID)
         }
         MailjetResponse response = await client.GetAsync(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 Respoonse

```
{
	"Count": 1,
	"Data": [
		{
			"ErrTreshold": 1,
			"ImportOptions": "",
			"Method": "addnoforce",
			"AliveAt": "2018-01-01T00:00:00",
			"ContactsListID": 123456,
			"Count": 12,
			"Current": 10,
			"DataID": 98765432123456780,
			"Errcount": 0,
			"ID": 987654,
			"JobEnd": "2018-01-01T00:00:00",
			"JobStart": "2018-01-01T00:00:00",
			"RequestAt": "2018-01-01T00:00:00",
			"Status": "Upload"
		}
	],
	"Total": 1
}
```

## Error Handling

If the `ErrCount` in the response of the `GET /csvimport/$job_ID` request is different than 0, you can retrieve a file with information about the errors that occurred during the import.

### Example

cURL
```shell
curl --user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
https://api.mailjet.com/v3/DATA/BatchJob/$job_id/CSVError/text:csv
```

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::$BatchjobCsverror, ['id' => $job_id]);
$response->success() && var_dump($response->getBody());
?>
```

Node.js
```javascript
/**
 *
 * Not available in Node, please refer to Curl
 *
 */
```

Ruby
```ruby
# Not available in Ruby, please refer to Curl
```

Python
```python
"""
Not available in Python, please refer to Curl
"""
```

Java
```java
/**
* Not available in Java , please refer to Curl
*/
```

Go
```go
/*
Not available in Go, please refer to Curl
*/
```

The returned file will be a copy of your original file with an added column describing the error for each line in error.

File uploaded with error:

```
"email","age"
"foo@example.org",42
"bar@example.com"
"sam@ple.co.uk",37
```

Error file content:

```
email,age,error
"bar@example.com", ###Too few columns at line
```