# Inbound Calls

## Introduction

Mailjet provides a way to receive email, in addition to sending them. To achieve that, you should start creating a [`parseroute`](/docs/api-reference/email-api/categories/parse/) which maps a given email address to your webhook.

For testing purposes, Mailjet provides auto generated email addresses on the domain `parse-in1.mailjet.com`.

For production setup, we however recommend you to setup the Parse API with your own domain, as explained below.

## Domains

Info
Maps to /inbound/domains.json

In Mailjet API, Inbound Domains are called [`parseroute`](/docs/api-reference/email-api/categories/parse/)

## Add-Domain

Info
Maps to /inbound/add-domain.json

Adding a domain is done through the [`sender`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/) resource.

## Check-Domain

Domain verification is tied to the [`sender`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/) resource.

Please refer to the [`Senders calls`](/#senders-calls) guide to learn more.

## Delete-Domain

Info
Maps to /inbound/delete-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->delete(Resources::$Sender, ['id' => $id]);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# Delete : 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 DELETE \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/sender/$ID \
	-H 'Content-Type: application/json' \
	-d '{
	}'
```

Node.js
```javascript
/**
 *
 * Delete : 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
  .delete('sender')
  .id($ID)
  .request()
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# Delete : 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
target = Mailjet::Sender.find($ID)
target.delete()
```

Python
```python
"""
Delete : 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))
id = '$ID'
result = mailjet.sender.delete(id=id)
print result.status_code
print result.json()
```

Go
```go
/*
Delete : 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"))
	mr := &MailjetRequest{
	  Resource: "sender",
	  ID: RESOURCE_ID,
	}
	err := mailjetClient.Delete(mr)
	if err != nil {
	  fmt.Println(err)
	}
}
```

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 {
    /**
     * Delete : 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, ID);
      response = client.delete(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

Issue a `DELETE` request on the [`sender`](/docs/api-reference/email-api/categories/sender-addresses-and-domains/) resource to set its status to `Deleted`

## Routes

Inbound routes are called [`parseroute`](/docs/api-reference/email-api/categories/parse/) in the Mailjet API.

## Add-Route

Info
Maps to /inbound/add-route.json

PHP
```php
<?php
require 'vendor/autoload.php';
use \Mailjet\Resources;
$mj = new \Mailjet\Client(getenv('MJ_APIKEY_PUBLIC'), getenv('MJ_APIKEY_PRIVATE'));
$body = [
    'APIKeyID' => "",
    'Email' => "miss@mailjet.com",
    'Url' => ""
];
$response = $mj->post(Resources::$Parseroute, ['body' => $body]);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# Create : ParseRoute description
curl -s \
	-X POST \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/parseroute \
	-H 'Content-Type: application/json' \
	-d '{
		"APIKeyID":"",
		"Email":"miss@mailjet.com",
		"Url":""
	}'
```

Node.js
```javascript
/**
 *
 * Create : ParseRoute description
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet.post('parseroute').request({
  APIKeyID: '',
  Email: 'miss@mailjet.com',
  Url: '',
})
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# Create : ParseRoute description
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::Parseroute.create(apikey_id: "",email: "miss@mailjet.com",url: "")
```

Python
```python
"""
Create : ParseRoute description
"""
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 = {
  'APIKeyID': '',
  'Email': 'miss@mailjet.com',
  'Url': ''
}
result = mailjet.parseroute.create(data=data)
print result.status_code
print result.json()
```

Go
```go
/*
Create : ParseRoute description
*/
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.Parseroute
	mr := &MailjetRequest{
	  Resource: "parseroute",
	}
	fmr := &FullMailjetRequest{
	  Info: mr,
	  Payload: &resources.Parseroute {
      APIKeyID: ,
      Email: "miss@mailjet.com",
      Url: ,
    },
	}
	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.Parseroute;
public class MyClass {
    /**
     * Create : ParseRoute description
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(Parseroute.resource)
						.property(Parseroute.APIKEYID, )
						.property(Parseroute.EMAIL, "miss@mailjet.com")
						.property(Parseroute.URL, );
      response = client.post(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

```json
{
  "Count": 1,
  "Data": [
    {
      "APIKeyID": "",
      "Email": "miss@mailjet.com",
      "ID": "",
      "Url": ""
    }
  ],
  "Total": 1
}
```

In order to create a new [`parseroute`](/docs/api-reference/email-api/categories/parse/), issue a `POST` request.

## Update-Route

Info
Maps to /inbound/update-route.json

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

Bash
```bash
# Modify : ParseRoute description
curl -s \
	-X PUT \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/parseroute/$ID \
	-H 'Content-Type: application/json' \
	-d '{
		"APIKeyID":"",
		"Url":""
	}'
```

Node.js
```javascript
/**
 *
 * Modify : ParseRoute description
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet
  .put('parseroute')
  .id($ID)
  .request({
    APIKeyID: '',
    Url: '',
  })
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# Modify : ParseRoute description
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
target = Mailjet::Parseroute.find($ID)
target.update_attributes(apikey_id: "",url: "")
```

Python
```python
"""
Modify : ParseRoute description
"""
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'
data = {
  'APIKeyID': '',
  'Url': ''
}
result = mailjet.parseroute.update(id=id, data=data)
print result.status_code
print result.json()
```

Go
```go
/*
Modify : ParseRoute description
*/
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"))
	mr := &MailjetRequest{
	  Resource: "parseroute",
	  ID: RESOURCE_ID,
	}
	fmr := &FullMailjetRequest{
	  Info: mr,
	  Payload: &resources.Parseroute {
      APIKeyID: ,
      Url: ,
    },
	}
	err := mailjetClient.Put(fmr)
	if err != nil {
	  fmt.Println(err)
	}
}
```

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.Parseroute;
public class MyClass {
    /**
     * Modify : ParseRoute description
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(Parseroute.resource, ID)
						.property(Parseroute.APIKEYID, )
						.property(Parseroute.URL, );
      response = client.put(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

```json
{
  "Count": 1,
  "Data": [
    {
      "APIKeyID": "",
      "Email": "miss@mailjet.com",
      "ID": "",
      "Url": ""
    }
  ],
  "Total": 1
}
```

In order to update [`parseroute`](/docs/api-reference/email-api/categories/parse/), issue a `PUT` request with its given ID.

## Delete-Route

Info
Maps to /inbound/delete-route.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->delete(Resources::$Parseroute, ['id' => $id]);
$response->success() && var_dump($response->getData());
?>
```

Bash
```bash
# Delete : ParseRoute description
curl -s \
	-X DELETE \
	--user "$MJ_APIKEY_PUBLIC:$MJ_APIKEY_PRIVATE" \
	https://api.mailjet.com/v3/REST/parseroute/$ID \
	-H 'Content-Type: application/json' \
	-d '{
	}'
```

Node.js
```javascript
/**
 *
 * Delete : ParseRoute description
 *
 */
var mailjet = require('node-mailjet').connect(
  process.env.MJ_APIKEY_PUBLIC,
  process.env.MJ_APIKEY_PRIVATE
)
var request = mailjet
  .delete('parseroute')
  .id($ID)
  .request()
request
  .on('success', function(response, body) {
    console.log(response.statusCode, body)
  })
  .on('error', function(err, response) {
    console.log(response.statusCode, err)
  })
```

Ruby
```ruby
# Delete : ParseRoute description
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
target = Mailjet::Parseroute.find($ID)
target.delete()
```

Python
```python
"""
Delete : ParseRoute description
"""
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.parseroute.delete(id=id)
print result.status_code
print result.json()
```

Go
```go
/*
Delete : ParseRoute description
*/
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"))
	mr := &MailjetRequest{
	  Resource: "parseroute",
	  ID: RESOURCE_ID,
	}
	err := mailjetClient.Delete(mr)
	if err != nil {
	  fmt.Println(err)
	}
}
```

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.Parseroute;
public class MyClass {
    /**
     * Delete : ParseRoute description
     */
    public static void main(String[] args) throws MailjetException {
      MailjetClient client;
      MailjetRequest request;
      MailjetResponse response;
      client = new MailjetClient("api key", "api secret");
      request = new MailjetRequest(Parseroute.resource, ID);
      response = client.delete(request);
      System.out.println(response.getStatus());
      System.out.println(response.getData());
    }
}
```

In order to delete [`parseroute`](/docs/api-reference/email-api/categories/parse/), issue a `DELETE` request with its given ID.