Créer une clé API

Générez une nouvelle clé API pour l’authentification.

POST/api-keys

Corps de la requête

namestringRequired

Le nom de la clé API pour l’identification.

scopestring

La portée de la clé API. Peut être ‘full’ ou ‘sending’ (par défaut : ‘full’).

sending_domain_idinteger

L’ID du domaine d’envoi auquel restreindre cette clé (par défaut : null).

const response = await fetch('https://api.emailit.com/v2/api-keys', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
name: 'Ma clé API',
scope: 'sending',
sending_domain_id: 1234567890
})
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/api-keys',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS => json_encode([
'name' => 'Ma clé API',
'scope' => 'sending',
'sending_domain_id' => 1234567890
]),
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.post(
'https://api.emailit.com/v2/api-keys',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
},
json={
    'name': 'Ma clé API',
    'scope': 'sending',
    'sending_domain_id': 1234567890
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/api-keys')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
name: 'Ma clé API',
scope: 'sending',
sending_domain_id: 1234567890
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/api-keys"

data := map[string]interface{}{
    "name": "Ma clé API",
    "scope": "sending",
    "sending_domain_id": 1234567890,
}

jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .post("https://api.emailit.com/v2/api-keys")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "name": "Ma clé API",
        "scope": "sending",
        "sending_domain_id": 1234567890
    }))
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;

public class CreateApiKey {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = "{\"name\":\"Ma clé API\",\"scope\":\"sending\",\"sending_domain_id\":1234567890}";
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/api-keys"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.ofString(jsonBody))
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class CreateApiKey
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new { name = "Ma clé API", scope = "sending", sending_domain_id = 1234567890 };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/api-keys", content);
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X POST https://api.emailit.com/v2/api-keys \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"name": "Ma clé API",
"scope": "sending",
"sending_domain_id": 1234567890
}'

{
"object": "api_key",
"id": 1234567890,
"name": "Ma clé API",
"scope": "sending",
"sending_domain_id": 1234567890,
"last_used_at": null,
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T00:00:00Z",
"key": "em_live_51RxCWJ...vS00p61e0qRE"
}

{
"error": {
"code": 400,
"message": "Requête incorrecte"
}
}

{
"error": {
"code": 409,
"message": "La clé API existe déjà"
},
"existing": {
"object": "api_key",
"id": 1234567890,
"name": "Ma clé API"
}
}

Obtenir une clé API

Récupérez les informations concernant une clé API spécifique de votre compte Emailit.

GET/api-keys/{id}

Paramètres de chemin

idstringRequired

L’identifiant de la clé API à récupérer.

const response = await fetch('https://api.emailit.com/v2/api-keys/ak_1234567890', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/api-keys/ak_1234567890',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/api-keys/ak_1234567890',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/api-keys/ak_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/api-keys/ak_1234567890"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/api-keys/ak_1234567890")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetApiKey {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/api-keys/ak_1234567890"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetApiKey
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/api-keys/ak_1234567890");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X GET https://api.emailit.com/v2/api-keys/ak_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "api_key",
"id": 1234567890,
"name": "Ma clé API",
"scope": "sending",
"sending_domain_id": 1234567890,
"last_used_at": "2021-01-01T12:00:00Z",
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T00:00:00Z"
}

{
"error": {
"code": 404,
"message": "Clé API introuvable"
}
}

Lister les clés API

Récupérez toutes les clés API de votre compte.

GET/api-keys

Paramètres de requête

pageinteger

Numéro de page pour la pagination (minimum : 1).

limitinteger

Nombre de clés API à retourner (minimum : 1, maximum : 100).

const response = await fetch('https://api.emailit.com/v2/api-keys?page=1&limit=10', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/api-keys?page=1&limit=10',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/api-keys',
params={
    'page': 1,
    'limit': 10
},
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/api-keys?page=1&limit=10')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/api-keys?page=1&limit=10"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/api-keys")
    .query(&[("page", "1"), ("limit", "10")])
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class ListApiKeys {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/api-keys?page=1&limit=10"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();

    HttpResponse<String> response = client.send(request,
        HttpResponse.BodyHandlers.ofString());

    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ListApiKeys
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization",
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");

        var response = await client.GetAsync(
            "https://api.emailit.com/v2/api-keys?page=1&limit=10");

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X GET "https://api.emailit.com/v2/api-keys?page=1&limit=10" \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"data": [
{
  "id": 1234567890,
  "name": "Ma clé API",
  "scope": "sending",
  "sending_domain_id": 1234567890,
  "last_used_at": "2021-01-01T12:00:00Z",
  "created_at": "2021-01-01T00:00:00Z",
  "updated_at": "2021-01-01T00:00:00Z"
},
{
  "id": 1234567891,
  "name": "Une autre clé API",
  "scope": "full",
  "sending_domain_id": null,
  "last_used_at": null,
  "created_at": "2021-01-02T00:00:00Z",
  "updated_at": "2021-01-02T00:00:00Z"
}
],
"next_page_url": "https://api.emailit.com/v2/api-keys?page=2&limit=10",
"previous_page_url": null
}

Mettre à jour une clé API

Modifiez le nom d’une clé API existante dans votre compte Emailit.

POST/api-keys/{id}

Paramètres de chemin

idstringRequired

L’identifiant de la clé API à mettre à jour.

Corps de la requête

namestringRequired

Le nouveau nom de la clé API.

const response = await fetch('https://api.emailit.com/v2/api-keys/ak_1234567890', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
name: 'Nouveau nom de clé API'
})
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/api-keys/ak_1234567890',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS => json_encode([
'name' => 'Nouveau nom de clé API'
]),
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.post(
'https://api.emailit.com/v2/api-keys/ak_1234567890',
json={
    'name': 'Nouveau nom de clé API'
},
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/api-keys/ak_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
name: 'Nouveau nom de clé API'
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/api-keys/ak_1234567890"

data := map[string]string{
    "name": "Nouveau nom de clé API",
}

jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .post("https://api.emailit.com/v2/api-keys/ak_1234567890")
    .json(&json!({
        "name": "Nouveau nom de clé API"
    }))
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class UpdateApiKey {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();

    String jsonBody = "{\"name\":\"Nouveau nom de clé API\"}";

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/api-keys/ak_1234567890"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
        .build();

    HttpResponse<String> response = client.send(request,
        HttpResponse.BodyHandlers.ofString());

    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class UpdateApiKey
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization",
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");

        var json = "{\"name\":\"Nouveau nom de clé API\"}";
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await client.PostAsync(
            "https://api.emailit.com/v2/api-keys/ak_1234567890", content);

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X POST https://api.emailit.com/v2/api-keys/ak_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"name": "Nouveau nom de clé API"
}'

{
"object": "api_key",
"id": 1234567890,
"name": "Nouveau nom de clé API",
"scope": "sending",
"sending_domain_id": 1234567890,
"last_used_at": "2021-01-01T12:00:00Z",
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"error": {
"code": 400,
"message": "Requête incorrecte"
}
}

{
"error": {
"code": 404,
"message": "Clé API introuvable"
}
}

{
"error": {
"code": 409,
"message": "Ce nom de clé API existe déjà"
}
}

Supprimer une clé API

Révoquez et supprimez une clé API de votre compte Emailit.

DELETE/api-keys/{id}

Paramètres de chemin

idstringRequired

L’identifiant de la clé API à supprimer.

const response = await fetch('https://api.emailit.com/v2/api-keys/ak_1234567890', {
method: 'DELETE',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/api-keys/ak_1234567890',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'DELETE',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.delete(
'https://api.emailit.com/v2/api-keys/ak_1234567890',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/api-keys/ak_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/api-keys/ak_1234567890"

req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

fmt.Println("Statut:", resp.Status)
}

use reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .delete("https://api.emailit.com/v2/api-keys/ak_1234567890")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

println!("Statut: {}", response.status());

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class DeleteApiKey {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/api-keys/ak_1234567890"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .DELETE()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println("Statut: " + response.statusCode());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class DeleteApiKey
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.DeleteAsync(
            "https://api.emailit.com/v2/api-keys/ak_1234567890");
        
        Console.WriteLine("Statut: " + response.StatusCode);
    }
}
}

curl -X DELETE https://api.emailit.com/v2/api-keys/ak_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "api_key",
"id": 1234567890,
"name": "Ma clé API",
"deleted": true
}

{
"error": {
"code": 404,
"message": "Clé API introuvable"
}
}

Créer une clé API

Corps de la requête

Obtenir une clé API

Paramètres de chemin

Lister les clés API

Paramètres de requête

Mettre à jour une clé API

Paramètres de chemin

Corps de la requête

Supprimer une clé API

Paramètres de chemin

Localisé par IA