{
    "api_key": "YOUR_API_KEY"
}

curl -X POST 'https://api.endpointr.com/v1/token' \
  -H 'Content-Type: application/json' \
  -d '{
    "api_key": "YOUR_API_KEY"
}'

const response = await fetch('https://api.endpointr.com/v1/token', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
      "api_key": "YOUR_API_KEY"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/token');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"api_key\": \"YOUR_API_KEY\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/token' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/token', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/token');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X PATCH 'https://api.endpointr.com/v1/token' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/token', {
  method: 'PATCH',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/token');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PATCH');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/token' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/token', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/token');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "publicKey": "-----BEGIN PUBLIC KEY-----\n…\n-----END PUBLIC KEY-----"
}

curl -X POST 'https://api.endpointr.com/v1/keys' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "publicKey": "-----BEGIN PUBLIC KEY-----\n…\n-----END PUBLIC KEY-----"
}'

const response = await fetch('https://api.endpointr.com/v1/keys', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "publicKey": "-----BEGIN PUBLIC KEY-----\n…\n-----END PUBLIC KEY-----"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/keys');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"publicKey\": \"-----BEGIN PUBLIC KEY-----\\n…\\n-----END PUBLIC KEY-----\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/keys' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/keys', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/keys');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/credentials/:service' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/credentials/:service', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/credentials/:service');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "api_key": "REPLACE_ME"
}

curl -X PUT 'https://api.endpointr.com/v1/credentials/:service' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "api_key": "REPLACE_ME"
}'

const response = await fetch('https://api.endpointr.com/v1/credentials/:service', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "api_key": "REPLACE_ME"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/credentials/:service');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"api_key\": \"REPLACE_ME\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/credentials/:service' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/credentials/:service', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/credentials/:service');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/vault' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/vault', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/vault');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/vault/:name' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/vault/:name', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/vault/:name');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "smtp_host": "email-smtp.us-east-1.amazonaws.com",
    "smtp_port": 587,
    "smtp_user": "AKIA…",
    "smtp_pass": "REPLACE_ME"
}

curl -X PUT 'https://api.endpointr.com/v1/vault/:name' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "smtp_host": "email-smtp.us-east-1.amazonaws.com",
    "smtp_port": 587,
    "smtp_user": "AKIA…",
    "smtp_pass": "REPLACE_ME"
}'

const response = await fetch('https://api.endpointr.com/v1/vault/:name', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "smtp_host": "email-smtp.us-east-1.amazonaws.com",
      "smtp_port": 587,
      "smtp_user": "AKIA…",
      "smtp_pass": "REPLACE_ME"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/vault/:name');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"smtp_host\": \"email-smtp.us-east-1.amazonaws.com\",\n    \"smtp_port\": 587,\n    \"smtp_user\": \"AKIA…\",\n    \"smtp_pass\": \"REPLACE_ME\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/vault/:name' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/vault/:name', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/vault/:name');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "prompt": "Write one sentence about rain."
}

curl -X POST 'https://api.endpointr.com/v1/ai/chat' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "prompt": "Write one sentence about rain."
}'

const response = await fetch('https://api.endpointr.com/v1/ai/chat', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "prompt": "Write one sentence about rain."
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/chat');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"prompt\": \"Write one sentence about rain.\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "prompt": "Write a haiku about rain.",
    "max_tokens": 200
}

curl -X POST 'https://api.endpointr.com/v1/ai/stream' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "prompt": "Write a haiku about rain.",
    "max_tokens": 200
}'

const response = await fetch('https://api.endpointr.com/v1/ai/stream', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "prompt": "Write a haiku about rain.",
      "max_tokens": 200
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/stream');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"prompt\": \"Write a haiku about rain.\",\n    \"max_tokens\": 200\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "prompt": "How do I refund a charge?",
    "retrieval": {
        "k": 4
    }
}

curl -X POST 'https://api.endpointr.com/v1/ai/conversation-stream' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "prompt": "How do I refund a charge?",
    "retrieval": {
        "k": 4
    }
}'

const response = await fetch('https://api.endpointr.com/v1/ai/conversation-stream', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "prompt": "How do I refund a charge?",
      "retrieval": {
          "k": 4
      }
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/conversation-stream');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"prompt\": \"How do I refund a charge?\",\n    \"retrieval\": {\n        \"k\": 4\n    }\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "prompt": "How do I refund a charge?",
    "retrieval": {
        "k": 4
    }
}

curl -X POST 'https://api.endpointr.com/v1/ai/conversation' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "prompt": "How do I refund a charge?",
    "retrieval": {
        "k": 4
    }
}'

const response = await fetch('https://api.endpointr.com/v1/ai/conversation', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "prompt": "How do I refund a charge?",
      "retrieval": {
          "k": 4
      }
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/conversation');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"prompt\": \"How do I refund a charge?\",\n    \"retrieval\": {\n        \"k\": 4\n    }\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "prompt": "A red fox in snow, photorealistic"
}

curl -X POST 'https://api.endpointr.com/v1/ai/image' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "prompt": "A red fox in snow, photorealistic"
}'

const response = await fetch('https://api.endpointr.com/v1/ai/image', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "prompt": "A red fox in snow, photorealistic"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/image');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"prompt\": \"A red fox in snow, photorealistic\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/ai/models?provider=openrouter' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/ai/models?provider=openrouter', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/models?provider=openrouter');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "model": "anthropic/claude-sonnet-4-6",
    "messages": [
        {
            "role": "system",
            "content": "You are concise."
        },
        {
            "role": "user",
            "content": "Reply with exactly: pong"
        }
    ],
    "max_tokens": 50
}

curl -X POST 'https://api.endpointr.com/v1/chat/completions' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "model": "anthropic/claude-sonnet-4-6",
    "messages": [
        {
            "role": "system",
            "content": "You are concise."
        },
        {
            "role": "user",
            "content": "Reply with exactly: pong"
        }
    ],
    "max_tokens": 50
}'

const response = await fetch('https://api.endpointr.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "model": "anthropic/claude-sonnet-4-6",
      "messages": [
          {
              "role": "system",
              "content": "You are concise."
          },
          {
              "role": "user",
              "content": "Reply with exactly: pong"
          }
      ],
      "max_tokens": 50
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/chat/completions');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"model\": \"anthropic/claude-sonnet-4-6\",\n    \"messages\": [\n        {\n            \"role\": \"system\",\n            \"content\": \"You are concise.\"\n        },\n        {\n            \"role\": \"user\",\n            \"content\": \"Reply with exactly: pong\"\n        }\n    ],\n    \"max_tokens\": 50\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "model": "anthropic/claude-sonnet-4-6",
    "messages": [
        {
            "role": "user",
            "content": "What's the weather in Copenhagen?"
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Return current weather for a city.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "City name"
                        }
                    },
                    "required": [
                        "city"
                    ]
                }
            }
        }
    ],
    "tool_choice": "auto"
}

curl -X POST 'https://api.endpointr.com/v1/chat/completions' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "model": "anthropic/claude-sonnet-4-6",
    "messages": [
        {
            "role": "user",
            "content": "What'\''s the weather in Copenhagen?"
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Return current weather for a city.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "City name"
                        }
                    },
                    "required": [
                        "city"
                    ]
                }
            }
        }
    ],
    "tool_choice": "auto"
}'

const response = await fetch('https://api.endpointr.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "model": "anthropic/claude-sonnet-4-6",
      "messages": [
          {
              "role": "user",
              "content": "What's the weather in Copenhagen?"
          }
      ],
      "tools": [
          {
              "type": "function",
              "function": {
                  "name": "get_weather",
                  "description": "Return current weather for a city.",
                  "parameters": {
                      "type": "object",
                      "properties": {
                          "city": {
                              "type": "string",
                              "description": "City name"
                          }
                      },
                      "required": [
                          "city"
                      ]
                  }
              }
          }
      ],
      "tool_choice": "auto"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/chat/completions');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"model\": \"anthropic/claude-sonnet-4-6\",\n    \"messages\": [\n        {\n            \"role\": \"user\",\n            \"content\": \"What's the weather in Copenhagen?\"\n        }\n    ],\n    \"tools\": [\n        {\n            \"type\": \"function\",\n            \"function\": {\n                \"name\": \"get_weather\",\n                \"description\": \"Return current weather for a city.\",\n                \"parameters\": {\n                    \"type\": \"object\",\n                    \"properties\": {\n                        \"city\": {\n                            \"type\": \"string\",\n                            \"description\": \"City name\"\n                        }\n                    },\n                    \"required\": [\n                        \"city\"\n                    ]\n                }\n            }\n        }\n    ],\n    \"tool_choice\": \"auto\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "model": "anthropic/claude-sonnet-4-6",
    "messages": [
        {
            "role": "user",
            "content": "Count from 1 to 5"
        }
    ],
    "stream": true,
    "max_tokens": 50
}

curl -X POST 'https://api.endpointr.com/v1/chat/completions' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "model": "anthropic/claude-sonnet-4-6",
    "messages": [
        {
            "role": "user",
            "content": "Count from 1 to 5"
        }
    ],
    "stream": true,
    "max_tokens": 50
}'

const response = await fetch('https://api.endpointr.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "model": "anthropic/claude-sonnet-4-6",
      "messages": [
          {
              "role": "user",
              "content": "Count from 1 to 5"
          }
      ],
      "stream": true,
      "max_tokens": 50
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/chat/completions');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"model\": \"anthropic/claude-sonnet-4-6\",\n    \"messages\": [\n        {\n            \"role\": \"user\",\n            \"content\": \"Count from 1 to 5\"\n        }\n    ],\n    \"stream\": true,\n    \"max_tokens\": 50\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "model": "openai/gpt-4o-mini",
    "messages": [
        {
            "role": "user",
            "content": "Say hi in one word."
        }
    ]
}

curl -X POST 'https://api.endpointr.com/v1/ai/completions' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "model": "openai/gpt-4o-mini",
    "messages": [
        {
            "role": "user",
            "content": "Say hi in one word."
        }
    ]
}'

const response = await fetch('https://api.endpointr.com/v1/ai/completions', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "model": "openai/gpt-4o-mini",
      "messages": [
          {
              "role": "user",
              "content": "Say hi in one word."
          }
      ]
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/completions');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"model\": \"openai/gpt-4o-mini\",\n    \"messages\": [\n        {\n            \"role\": \"user\",\n            \"content\": \"Say hi in one word.\"\n        }\n    ]\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
    "format": "png"
}

curl -X POST 'https://api.endpointr.com/v1/ai/upload' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
    "format": "png"
}'

const response = await fetch('https://api.endpointr.com/v1/ai/upload', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
      "format": "png"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/upload');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"image_base64\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=\",\n    \"format\": \"png\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/ai/video' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/ai/video', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/video');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/ai/video/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/ai/video/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/video/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "model": "bytedance/seedance-2.0/text-to-video",
    "prompt": "A red fox running through snow at sunrise, cinematic.",
    "ratio": "16:9",
    "duration": 5,
    "resolution": "1080p"
}

curl -X POST 'https://api.endpointr.com/v1/ai/video' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "model": "bytedance/seedance-2.0/text-to-video",
    "prompt": "A red fox running through snow at sunrise, cinematic.",
    "ratio": "16:9",
    "duration": 5,
    "resolution": "1080p"
}'

const response = await fetch('https://api.endpointr.com/v1/ai/video', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "model": "bytedance/seedance-2.0/text-to-video",
      "prompt": "A red fox running through snow at sunrise, cinematic.",
      "ratio": "16:9",
      "duration": 5,
      "resolution": "1080p"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/video');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"model\": \"bytedance/seedance-2.0/text-to-video\",\n    \"prompt\": \"A red fox running through snow at sunrise, cinematic.\",\n    \"ratio\": \"16:9\",\n    \"duration\": 5,\n    \"resolution\": \"1080p\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "prompt": "What is in this image?",
    "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Cat_November_2010-1a.jpg/640px-Cat_November_2010-1a.jpg",
    "max_tokens": 500
}

curl -X POST 'https://api.endpointr.com/v1/ai/vision' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "prompt": "What is in this image?",
    "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Cat_November_2010-1a.jpg/640px-Cat_November_2010-1a.jpg",
    "max_tokens": 500
}'

const response = await fetch('https://api.endpointr.com/v1/ai/vision', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "prompt": "What is in this image?",
      "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Cat_November_2010-1a.jpg/640px-Cat_November_2010-1a.jpg",
      "max_tokens": 500
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/ai/vision');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"prompt\": \"What is in this image?\",\n    \"image_url\": \"https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Cat_November_2010-1a.jpg/640px-Cat_November_2010-1a.jpg\",\n    \"max_tokens\": 500\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/webhooks/events' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/webhooks/events', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/webhooks/events');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/webhooks' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/webhooks', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/webhooks');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "event": "HeaderMarkdownExtractor.getByParam",
    "url": "https://receiver.example.com/webhook"
}

curl -X POST 'https://api.endpointr.com/v1/webhooks' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "event": "HeaderMarkdownExtractor.getByParam",
    "url": "https://receiver.example.com/webhook"
}'

const response = await fetch('https://api.endpointr.com/v1/webhooks', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "event": "HeaderMarkdownExtractor.getByParam",
      "url": "https://receiver.example.com/webhook"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/webhooks');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"event\": \"HeaderMarkdownExtractor.getByParam\",\n    \"url\": \"https://receiver.example.com/webhook\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/webhooks/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/webhooks/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/webhooks/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/webhooks/inbound/meta-ads?hub.mode=subscribe&hub.verify_token=%E2%80%A6&hub.challenge=12345'

const response = await fetch('https://api.endpointr.com/v1/webhooks/inbound/meta-ads?hub.mode=subscribe&hub.verify_token=%E2%80%A6&hub.challenge=12345', {
  method: 'GET'
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/webhooks/inbound/meta-ads?hub.mode=subscribe&hub.verify_token=%E2%80%A6&hub.challenge=12345');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

const response = await fetch('https://api.endpointr.com/v1/webhooks/inbound/meta-ads', {
  method: 'POST'
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/webhooks/inbound/meta-ads');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/profylr/company?domain=example.com&country=dk&refresh=false' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/profylr/company?domain=example.com&country=dk&refresh=false', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/profylr/company?domain=example.com&country=dk&refresh=false');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "operation": "export",
    "identifier": "jane@example.com"
}

curl -X POST 'https://api.endpointr.com/v1/profylr/dsr' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "operation": "export",
    "identifier": "jane@example.com"
}'

const response = await fetch('https://api.endpointr.com/v1/profylr/dsr', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "operation": "export",
      "identifier": "jane@example.com"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/profylr/dsr');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"operation\": \"export\",\n    \"identifier\": \"jane@example.com\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "scope": "email",
    "value": "jane@example.com",
    "channels": [
        "email",
        "linkedin"
    ],
    "reason": "Subject requested removal"
}

curl -X POST 'https://api.endpointr.com/v1/profylr/opt-out' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "scope": "email",
    "value": "jane@example.com",
    "channels": [
        "email",
        "linkedin"
    ],
    "reason": "Subject requested removal"
}'

const response = await fetch('https://api.endpointr.com/v1/profylr/opt-out', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "scope": "email",
      "value": "jane@example.com",
      "channels": [
          "email",
          "linkedin"
      ],
      "reason": "Subject requested removal"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/profylr/opt-out');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"scope\": \"email\",\n    \"value\": \"jane@example.com\",\n    \"channels\": [\n        \"email\",\n        \"linkedin\"\n    ],\n    \"reason\": \"Subject requested removal\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/profylr/person?email=jane%40example.com&country=dk&refresh=false' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/profylr/person?email=jane%40example.com&country=dk&refresh=false', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/profylr/person?email=jane%40example.com&country=dk&refresh=false');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/profylr/ping' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/profylr/ping', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/profylr/ping');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/accounts?provider=dinero&kind=entry' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/accounts?provider=dinero&kind=entry', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/accounts?provider=dinero&kind=entry');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/contacts/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/contacts/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/contacts/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/contacts?provider=dinero&fields=Name%2CContactGuid%2CEmail&pageSize=100' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/contacts?provider=dinero&fields=Name%2CContactGuid%2CEmail&pageSize=100', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/contacts?provider=dinero&fields=Name%2CContactGuid%2CEmail&pageSize=100');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "provider": "dinero",
    "name": "Acme Corp",
    "email": "acme@example.com",
    "country": "DK",
    "is_company": true,
    "vat_number": "12345678"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/contacts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "provider": "dinero",
    "name": "Acme Corp",
    "email": "acme@example.com",
    "country": "DK",
    "is_company": true,
    "vat_number": "12345678"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/contacts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "provider": "dinero",
      "name": "Acme Corp",
      "email": "acme@example.com",
      "country": "DK",
      "is_company": true,
      "vat_number": "12345678"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/contacts');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"provider\": \"dinero\",\n    \"name\": \"Acme Corp\",\n    \"email\": \"acme@example.com\",\n    \"country\": \"DK\",\n    \"is_company\": true,\n    \"vat_number\": \"12345678\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "provider": "dinero",
    "name": "Acme Holdings"
}

curl -X PUT 'https://api.endpointr.com/v1/accounting/contacts/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "provider": "dinero",
    "name": "Acme Holdings"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/contacts/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "provider": "dinero",
      "name": "Acme Holdings"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/contacts/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"provider\": \"dinero\",\n    \"name\": \"Acme Holdings\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/accounting/contacts/:id?provider=dinero' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/contacts/:id?provider=dinero', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/contacts/:id?provider=dinero');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/invoices/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/invoices/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/invoices/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/invoices?provider=dinero&pageSize=50' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/invoices?provider=dinero&pageSize=50', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/invoices?provider=dinero&pageSize=50');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "provider": "dinero",
    "contact_id": "<contact-guid>",
    "currency": "DKK",
    "date": "2026-04-22",
    "lines": [
        {
            "description": "Consulting",
            "quantity": 5,
            "unit": "hours",
            "unit_price": 1000,
            "account_number": 1000
        }
    ]
}

curl -X POST 'https://api.endpointr.com/v1/accounting/invoices' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "provider": "dinero",
    "contact_id": "<contact-guid>",
    "currency": "DKK",
    "date": "2026-04-22",
    "lines": [
        {
            "description": "Consulting",
            "quantity": 5,
            "unit": "hours",
            "unit_price": 1000,
            "account_number": 1000
        }
    ]
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/invoices', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "provider": "dinero",
      "contact_id": "<contact-guid>",
      "currency": "DKK",
      "date": "2026-04-22",
      "lines": [
          {
              "description": "Consulting",
              "quantity": 5,
              "unit": "hours",
              "unit_price": 1000,
              "account_number": 1000
          }
      ]
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/invoices');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"provider\": \"dinero\",\n    \"contact_id\": \"<contact-guid>\",\n    \"currency\": \"DKK\",\n    \"date\": \"2026-04-22\",\n    \"lines\": [\n        {\n            \"description\": \"Consulting\",\n            \"quantity\": 5,\n            \"unit\": \"hours\",\n            \"unit_price\": 1000,\n            \"account_number\": 1000\n        }\n    ]\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "provider": "dinero",
    "contact_id": "<guid>",
    "lines": []
}

curl -X PUT 'https://api.endpointr.com/v1/accounting/invoices/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "provider": "dinero",
    "contact_id": "<guid>",
    "lines": []
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/invoices/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "provider": "dinero",
      "contact_id": "<guid>",
      "lines": []
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/invoices/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"provider\": \"dinero\",\n    \"contact_id\": \"<guid>\",\n    \"lines\": []\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/accounting/invoices/:id?provider=dinero' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/invoices/:id?provider=dinero', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/invoices/:id?provider=dinero');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/products/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/products/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/products/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/products?provider=dinero' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/products?provider=dinero', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/products?provider=dinero');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "provider": "dinero",
    "name": "Consulting",
    "unit_price": 1000,
    "unit": "hours",
    "account_number": 1000
}

curl -X POST 'https://api.endpointr.com/v1/accounting/products' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "provider": "dinero",
    "name": "Consulting",
    "unit_price": 1000,
    "unit": "hours",
    "account_number": 1000
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/products', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "provider": "dinero",
      "name": "Consulting",
      "unit_price": 1000,
      "unit": "hours",
      "account_number": 1000
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/products');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"provider\": \"dinero\",\n    \"name\": \"Consulting\",\n    \"unit_price\": 1000,\n    \"unit\": \"hours\",\n    \"account_number\": 1000\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "provider": "dinero",
    "unit_price": 1200
}

curl -X PUT 'https://api.endpointr.com/v1/accounting/products/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "provider": "dinero",
    "unit_price": 1200
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/products/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "provider": "dinero",
      "unit_price": 1200
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/products/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"provider\": \"dinero\",\n    \"unit_price\": 1200\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/accounting/products/:id?provider=dinero' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/products/:id?provider=dinero', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/products/:id?provider=dinero');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/bindings/bindings' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/bindings/bindings', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/bindings/bindings');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/bindings/bindings/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/bindings/bindings/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/bindings/bindings/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "trigger_event": "stripe.payment_intent.succeeded",
    "action": "dinero.invoice.add_payment",
    "enabled": true,
    "mapping": {
        "id": "$.object.metadata.invoice_id",
        "amount": "$.object.amount",
        "currency": "$.object.currency",
        "description": "Stripe payment $.object.id",
        "external_reference": "$.object.id"
    }
}

curl -X POST 'https://api.endpointr.com/v1/bindings/bindings' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "trigger_event": "stripe.payment_intent.succeeded",
    "action": "dinero.invoice.add_payment",
    "enabled": true,
    "mapping": {
        "id": "$.object.metadata.invoice_id",
        "amount": "$.object.amount",
        "currency": "$.object.currency",
        "description": "Stripe payment $.object.id",
        "external_reference": "$.object.id"
    }
}'

const response = await fetch('https://api.endpointr.com/v1/bindings/bindings', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "trigger_event": "stripe.payment_intent.succeeded",
      "action": "dinero.invoice.add_payment",
      "enabled": true,
      "mapping": {
          "id": "$.object.metadata.invoice_id",
          "amount": "$.object.amount",
          "currency": "$.object.currency",
          "description": "Stripe payment $.object.id",
          "external_reference": "$.object.id"
      }
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/bindings/bindings');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"trigger_event\": \"stripe.payment_intent.succeeded\",\n    \"action\": \"dinero.invoice.add_payment\",\n    \"enabled\": true,\n    \"mapping\": {\n        \"id\": \"\$.object.metadata.invoice_id\",\n        \"amount\": \"\$.object.amount\",\n        \"currency\": \"\$.object.currency\",\n        \"description\": \"Stripe payment \$.object.id\",\n        \"external_reference\": \"\$.object.id\"\n    }\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "trigger_event": "stripe.payment_intent.succeeded",
    "action": "dinero.invoice.add_payment",
    "enabled": false,
    "mapping": []
}

curl -X PUT 'https://api.endpointr.com/v1/bindings/bindings/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "trigger_event": "stripe.payment_intent.succeeded",
    "action": "dinero.invoice.add_payment",
    "enabled": false,
    "mapping": []
}'

const response = await fetch('https://api.endpointr.com/v1/bindings/bindings/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "trigger_event": "stripe.payment_intent.succeeded",
      "action": "dinero.invoice.add_payment",
      "enabled": false,
      "mapping": []
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/bindings/bindings/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"trigger_event\": \"stripe.payment_intent.succeeded\",\n    \"action\": \"dinero.invoice.add_payment\",\n    \"enabled\": false,\n    \"mapping\": []\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/bindings/bindings/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/bindings/bindings/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/bindings/bindings/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/bindings/inbound-webhooks' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/bindings/inbound-webhooks', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/bindings/inbound-webhooks');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "provider": "stripe",
    "secret": "whsec_...",
    "label": "Production Stripe"
}

curl -X POST 'https://api.endpointr.com/v1/bindings/inbound-webhooks' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "provider": "stripe",
    "secret": "whsec_...",
    "label": "Production Stripe"
}'

const response = await fetch('https://api.endpointr.com/v1/bindings/inbound-webhooks', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "provider": "stripe",
      "secret": "whsec_...",
      "label": "Production Stripe"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/bindings/inbound-webhooks');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"provider\": \"stripe\",\n    \"secret\": \"whsec_...\",\n    \"label\": \"Production Stripe\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/bindings/inbound-webhooks/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/bindings/inbound-webhooks/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/bindings/inbound-webhooks/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/crawlers/cms-crawler?url=https%3A%2F%2Fexample.com' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/crawlers/cms-crawler?url=https%3A%2F%2Fexample.com', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/cms-crawler?url=https%3A%2F%2Fexample.com');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "url": "https://example.com"
}

curl -X POST 'https://api.endpointr.com/v1/crawlers/cms-crawler' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "url": "https://example.com"
}'

const response = await fetch('https://api.endpointr.com/v1/crawlers/cms-crawler', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "url": "https://example.com"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/cms-crawler');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"url\": \"https://example.com\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/crawlers/cvr-crawler?url=https%3A%2F%2Fexample.dk' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/crawlers/cvr-crawler?url=https%3A%2F%2Fexample.dk', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/cvr-crawler?url=https%3A%2F%2Fexample.dk');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "url": "https://example.dk"
}

curl -X POST 'https://api.endpointr.com/v1/crawlers/cvr-crawler' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "url": "https://example.dk"
}'

const response = await fetch('https://api.endpointr.com/v1/crawlers/cvr-crawler', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "url": "https://example.dk"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/cvr-crawler');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"url\": \"https://example.dk\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/crawlers/email-crawler?url=https%3A%2F%2Fexample.com' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/crawlers/email-crawler?url=https%3A%2F%2Fexample.com', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/email-crawler?url=https%3A%2F%2Fexample.com');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "url": "https://example.com"
}

curl -X POST 'https://api.endpointr.com/v1/crawlers/email-crawler' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "url": "https://example.com"
}'

const response = await fetch('https://api.endpointr.com/v1/crawlers/email-crawler', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "url": "https://example.com"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/email-crawler');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"url\": \"https://example.com\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/crawlers/link-crawler?url=https%3A%2F%2Fexample.com' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/crawlers/link-crawler?url=https%3A%2F%2Fexample.com', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/link-crawler?url=https%3A%2F%2Fexample.com');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "url": "https://example.com"
}

curl -X POST 'https://api.endpointr.com/v1/crawlers/link-crawler' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "url": "https://example.com"
}'

const response = await fetch('https://api.endpointr.com/v1/crawlers/link-crawler', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "url": "https://example.com"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/link-crawler');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"url\": \"https://example.com\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/crawlers/logo-crawler?url=https%3A%2F%2Fexample.com' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/crawlers/logo-crawler?url=https%3A%2F%2Fexample.com', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/logo-crawler?url=https%3A%2F%2Fexample.com');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "url": "https://example.com"
}

curl -X POST 'https://api.endpointr.com/v1/crawlers/logo-crawler' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "url": "https://example.com"
}'

const response = await fetch('https://api.endpointr.com/v1/crawlers/logo-crawler', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "url": "https://example.com"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/logo-crawler');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"url\": \"https://example.com\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/crawlers/phone-crawler?url=https%3A%2F%2Fexample.com' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/crawlers/phone-crawler?url=https%3A%2F%2Fexample.com', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/phone-crawler?url=https%3A%2F%2Fexample.com');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "url": "https://example.com"
}

curl -X POST 'https://api.endpointr.com/v1/crawlers/phone-crawler' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "url": "https://example.com"
}'

const response = await fetch('https://api.endpointr.com/v1/crawlers/phone-crawler', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "url": "https://example.com"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/phone-crawler');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"url\": \"https://example.com\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/crawlers/social-profiles-crawler?url=https%3A%2F%2Fexample.com' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/crawlers/social-profiles-crawler?url=https%3A%2F%2Fexample.com', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/social-profiles-crawler?url=https%3A%2F%2Fexample.com');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "url": "https://example.com"
}

curl -X POST 'https://api.endpointr.com/v1/crawlers/social-profiles-crawler' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "url": "https://example.com"
}'

const response = await fetch('https://api.endpointr.com/v1/crawlers/social-profiles-crawler', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "url": "https://example.com"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/crawlers/social-profiles-crawler');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"url\": \"https://example.com\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/generals/cvr?cvr=12345678&country=dk&agent=Endpointr' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/generals/cvr?cvr=12345678&country=dk&agent=Endpointr', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/generals/cvr?cvr=12345678&country=dk&agent=Endpointr');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/generals/dns?ip=1.1.1.1&action=reverse' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/generals/dns?ip=1.1.1.1&action=reverse', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/generals/dns?ip=1.1.1.1&action=reverse');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/generals/ip?ip=1.1.1.1' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/generals/ip?ip=1.1.1.1', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/generals/ip?ip=1.1.1.1');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/generals/redirect?url=https%3A%2F%2Fexample.com&action=chain' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/generals/redirect?url=https%3A%2F%2Fexample.com&action=chain', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/generals/redirect?url=https%3A%2F%2Fexample.com&action=chain');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/generals/remote' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/generals/remote', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/generals/remote');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/generals/remote' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/generals/remote', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/generals/remote');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/generals/vat?countrycode=DK&vatno=12345678' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/generals/vat?countrycode=DK&vatno=12345678', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/generals/vat?countrycode=DK&vatno=12345678');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "base_image_base64": "<base64>",
    "overlay_image_base64": "<base64>",
    "x": 0,
    "y": 0,
    "opacity": 1,
    "format": "png"
}

curl -X POST 'https://api.endpointr.com/v1/graphics/combine' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "base_image_base64": "<base64>",
    "overlay_image_base64": "<base64>",
    "x": 0,
    "y": 0,
    "opacity": 1,
    "format": "png"
}'

const response = await fetch('https://api.endpointr.com/v1/graphics/combine', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "base_image_base64": "<base64>",
      "overlay_image_base64": "<base64>",
      "x": 0,
      "y": 0,
      "opacity": 1,
      "format": "png"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/graphics/combine');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"base_image_base64\": \"<base64>\",\n    \"overlay_image_base64\": \"<base64>\",\n    \"x\": 0,\n    \"y\": 0,\n    \"opacity\": 1,\n    \"format\": \"png\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "image_base64": "<base64>",
    "format": "jpeg",
    "quality": 85
}

curl -X POST 'https://api.endpointr.com/v1/graphics/convert' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "image_base64": "<base64>",
    "format": "jpeg",
    "quality": 85
}'

const response = await fetch('https://api.endpointr.com/v1/graphics/convert', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "image_base64": "<base64>",
      "format": "jpeg",
      "quality": 85
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/graphics/convert');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"image_base64\": \"<base64>\",\n    \"format\": \"jpeg\",\n    \"quality\": 85\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "image_base64": "<base64>",
    "x": 0,
    "y": 0,
    "width": 200,
    "height": 200,
    "format": "png"
}

curl -X POST 'https://api.endpointr.com/v1/graphics/crop' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "image_base64": "<base64>",
    "x": 0,
    "y": 0,
    "width": 200,
    "height": 200,
    "format": "png"
}'

const response = await fetch('https://api.endpointr.com/v1/graphics/crop', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "image_base64": "<base64>",
      "x": 0,
      "y": 0,
      "width": 200,
      "height": 200,
      "format": "png"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/graphics/crop');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"image_base64\": \"<base64>\",\n    \"x\": 0,\n    \"y\": 0,\n    \"width\": 200,\n    \"height\": 200,\n    \"format\": \"png\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "image_base64": "<base64>",
    "width": 300,
    "height": 200,
    "mode": "cover",
    "format": "png",
    "quality": 85
}

curl -X POST 'https://api.endpointr.com/v1/graphics/resize' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "image_base64": "<base64>",
    "width": 300,
    "height": 200,
    "mode": "cover",
    "format": "png",
    "quality": 85
}'

const response = await fetch('https://api.endpointr.com/v1/graphics/resize', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "image_base64": "<base64>",
      "width": 300,
      "height": 200,
      "mode": "cover",
      "format": "png",
      "quality": 85
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/graphics/resize');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"image_base64\": \"<base64>\",\n    \"width\": 300,\n    \"height\": 200,\n    \"mode\": \"cover\",\n    \"format\": \"png\",\n    \"quality\": 85\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/graphics/text2-img?text=Sponsored' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/graphics/text2-img?text=Sponsored', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/graphics/text2-img?text=Sponsored');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "text": "Sponsored"
}

curl -X POST 'https://api.endpointr.com/v1/graphics/text2-img' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "text": "Sponsored"
}'

const response = await fetch('https://api.endpointr.com/v1/graphics/text2-img', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "text": "Sponsored"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/graphics/text2-img');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"text\": \"Sponsored\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
    "format": "png"
}

curl -X POST 'https://api.endpointr.com/v1/images/host' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
    "format": "png"
}'

const response = await fetch('https://api.endpointr.com/v1/images/host', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
      "format": "png"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/images/host');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"image_base64\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=\",\n    \"format\": \"png\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/mail/mailchimp' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/mailchimp', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/mailchimp');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "email": "user@example.com",
    "list_id": "abc123",
    "merge_fields": {
        "FNAME": "Alice"
    }
}

curl -X POST 'https://api.endpointr.com/v1/mail/mailchimp' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "email": "user@example.com",
    "list_id": "abc123",
    "merge_fields": {
        "FNAME": "Alice"
    }
}'

const response = await fetch('https://api.endpointr.com/v1/mail/mailchimp', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "email": "user@example.com",
      "list_id": "abc123",
      "merge_fields": {
          "FNAME": "Alice"
      }
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/mailchimp');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"email\": \"user@example.com\",\n    \"list_id\": \"abc123\",\n    \"merge_fields\": {\n        \"FNAME\": \"Alice\"\n    }\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "list_id": "abc123",
    "merge_fields": {
        "FNAME": "Bob"
    }
}

curl -X PUT 'https://api.endpointr.com/v1/mail/mailchimp/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "list_id": "abc123",
    "merge_fields": {
        "FNAME": "Bob"
    }
}'

const response = await fetch('https://api.endpointr.com/v1/mail/mailchimp/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "list_id": "abc123",
      "merge_fields": {
          "FNAME": "Bob"
      }
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/mailchimp/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"list_id\": \"abc123\",\n    \"merge_fields\": {\n        \"FNAME\": \"Bob\"\n    }\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/mail/mailchimp/:id?list_id=abc123' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/mailchimp/:id?list_id=abc123', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/mailchimp/:id?list_id=abc123');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/mail/missive-contacts/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-contacts/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-contacts/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/mail/missive-contacts?contact_book=%7B%7Bmissive_contact_book%7D%7D&limit=50' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-contacts?contact_book=%7B%7Bmissive_contact_book%7D%7D&limit=50', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-contacts?contact_book=%7B%7Bmissive_contact_book%7D%7D&limit=50');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "contact_book": "{{missive_contact_book}}",
    "first_name": "Alice",
    "last_name": "Doe",
    "infos": [
        {
            "kind": "email",
            "value": "alice@example.com"
        }
    ]
}

curl -X POST 'https://api.endpointr.com/v1/mail/missive-contacts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "contact_book": "{{missive_contact_book}}",
    "first_name": "Alice",
    "last_name": "Doe",
    "infos": [
        {
            "kind": "email",
            "value": "alice@example.com"
        }
    ]
}'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-contacts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "contact_book": "{{missive_contact_book}}",
      "first_name": "Alice",
      "last_name": "Doe",
      "infos": [
          {
              "kind": "email",
              "value": "alice@example.com"
          }
      ]
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-contacts');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"contact_book\": \"{{missive_contact_book}}\",\n    \"first_name\": \"Alice\",\n    \"last_name\": \"Doe\",\n    \"infos\": [\n        {\n            \"kind\": \"email\",\n            \"value\": \"alice@example.com\"\n        }\n    ]\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "first_name": "Alice (updated)"
}

curl -X PUT 'https://api.endpointr.com/v1/mail/missive-contacts/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "first_name": "Alice (updated)"
}'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-contacts/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "first_name": "Alice (updated)"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-contacts/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"first_name\": \"Alice (updated)\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/mail/missive-conversations/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-conversations/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-conversations/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/mail/missive-conversations?limit=10&inbox=true' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-conversations?limit=10&inbox=true', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-conversations?limit=10&inbox=true');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "from_field": {
        "address": "me@example.com",
        "name": "Me"
    },
    "to_fields": [
        {
            "address": "you@example.com",
            "name": "You"
        }
    ],
    "subject": "Hello from Endpointr",
    "body": "<p>This was created via the Missive REST API relay.</p>",
    "send": false
}

curl -X POST 'https://api.endpointr.com/v1/mail/missive-drafts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "from_field": {
        "address": "me@example.com",
        "name": "Me"
    },
    "to_fields": [
        {
            "address": "you@example.com",
            "name": "You"
        }
    ],
    "subject": "Hello from Endpointr",
    "body": "<p>This was created via the Missive REST API relay.</p>",
    "send": false
}'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-drafts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "from_field": {
          "address": "me@example.com",
          "name": "Me"
      },
      "to_fields": [
          {
              "address": "you@example.com",
              "name": "You"
          }
      ],
      "subject": "Hello from Endpointr",
      "body": "<p>This was created via the Missive REST API relay.</p>",
      "send": false
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-drafts');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"from_field\": {\n        \"address\": \"me@example.com\",\n        \"name\": \"Me\"\n    },\n    \"to_fields\": [\n        {\n            \"address\": \"you@example.com\",\n            \"name\": \"You\"\n        }\n    ],\n    \"subject\": \"Hello from Endpointr\",\n    \"body\": \"<p>This was created via the Missive REST API relay.</p>\",\n    \"send\": false\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/mail/missive-drafts/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-drafts/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-drafts/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/mail/missive-messages/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-messages/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-messages/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/mail/missive-messages?conversation=%7B%7Bmissive_conversation%7D%7D&limit=20' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-messages?conversation=%7B%7Bmissive_conversation%7D%7D&limit=20', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-messages?conversation=%7B%7Bmissive_conversation%7D%7D&limit=20');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "conversation": "{{missive_conversation}}",
    "notification": {
        "title": "New comment",
        "body": "Posted from Endpointr"
    },
    "markdown": "Heads up — see the new attachment."
}

curl -X POST 'https://api.endpointr.com/v1/mail/missive-posts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "conversation": "{{missive_conversation}}",
    "notification": {
        "title": "New comment",
        "body": "Posted from Endpointr"
    },
    "markdown": "Heads up — see the new attachment."
}'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-posts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "conversation": "{{missive_conversation}}",
      "notification": {
          "title": "New comment",
          "body": "Posted from Endpointr"
      },
      "markdown": "Heads up — see the new attachment."
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-posts');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"conversation\": \"{{missive_conversation}}\",\n    \"notification\": {\n        \"title\": \"New comment\",\n        \"body\": \"Posted from Endpointr\"\n    },\n    \"markdown\": \"Heads up — see the new attachment.\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "title": "Follow up with customer",
    "organization": "{{missive_organization}}",
    "assignees": [
        "{{missive_user}}"
    ],
    "due_at": 1764547200
}

curl -X POST 'https://api.endpointr.com/v1/mail/missive-tasks' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "title": "Follow up with customer",
    "organization": "{{missive_organization}}",
    "assignees": [
        "{{missive_user}}"
    ],
    "due_at": 1764547200
}'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-tasks', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "title": "Follow up with customer",
      "organization": "{{missive_organization}}",
      "assignees": [
          "{{missive_user}}"
      ],
      "due_at": 1764547200
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-tasks');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"title\": \"Follow up with customer\",\n    \"organization\": \"{{missive_organization}}\",\n    \"assignees\": [\n        \"{{missive_user}}\"\n    ],\n    \"due_at\": 1764547200\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "state": "in_progress"
}

curl -X PUT 'https://api.endpointr.com/v1/mail/missive-tasks/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "state": "in_progress"
}'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-tasks/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "state": "in_progress"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-tasks/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"state\": \"in_progress\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/mail/missive-tasks/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/mail/missive-tasks/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/mail/missive-tasks/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ad-sets/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-sets/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-sets/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ad-sets?account_id=%7B%7Bmeta_ad_account_id%7D%7D&refresh=false' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-sets?account_id=%7B%7Bmeta_ad_account_id%7D%7D&refresh=false', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-sets?account_id=%7B%7Bmeta_ad_account_id%7D%7D&refresh=false');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "account_id": "{{meta_ad_account_id}}",
    "campaign_id": "120000000000000",
    "name": "EU desktop — clicks",
    "status": "PAUSED",
    "billing_event": "IMPRESSIONS",
    "optimization_goal": "LINK_CLICKS",
    "daily_budget": 2500,
    "targeting": {
        "geo_locations": {
            "countries": [
                "DK",
                "SE",
                "NO"
            ]
        },
        "age_min": 25,
        "age_max": 55,
        "publisher_platforms": [
            "facebook",
            "instagram"
        ]
    },
    "start_time": "2026-06-01T00:00:00+0000"
}

curl -X POST 'https://api.endpointr.com/v1/marketing/ad-sets' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "account_id": "{{meta_ad_account_id}}",
    "campaign_id": "120000000000000",
    "name": "EU desktop — clicks",
    "status": "PAUSED",
    "billing_event": "IMPRESSIONS",
    "optimization_goal": "LINK_CLICKS",
    "daily_budget": 2500,
    "targeting": {
        "geo_locations": {
            "countries": [
                "DK",
                "SE",
                "NO"
            ]
        },
        "age_min": 25,
        "age_max": 55,
        "publisher_platforms": [
            "facebook",
            "instagram"
        ]
    },
    "start_time": "2026-06-01T00:00:00+0000"
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-sets', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "account_id": "{{meta_ad_account_id}}",
      "campaign_id": "120000000000000",
      "name": "EU desktop — clicks",
      "status": "PAUSED",
      "billing_event": "IMPRESSIONS",
      "optimization_goal": "LINK_CLICKS",
      "daily_budget": 2500,
      "targeting": {
          "geo_locations": {
              "countries": [
                  "DK",
                  "SE",
                  "NO"
              ]
          },
          "age_min": 25,
          "age_max": 55,
          "publisher_platforms": [
              "facebook",
              "instagram"
          ]
      },
      "start_time": "2026-06-01T00:00:00+0000"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-sets');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"account_id\": \"{{meta_ad_account_id}}\",\n    \"campaign_id\": \"120000000000000\",\n    \"name\": \"EU desktop — clicks\",\n    \"status\": \"PAUSED\",\n    \"billing_event\": \"IMPRESSIONS\",\n    \"optimization_goal\": \"LINK_CLICKS\",\n    \"daily_budget\": 2500,\n    \"targeting\": {\n        \"geo_locations\": {\n            \"countries\": [\n                \"DK\",\n                \"SE\",\n                \"NO\"\n            ]\n        },\n        \"age_min\": 25,\n        \"age_max\": 55,\n        \"publisher_platforms\": [\n            \"facebook\",\n            \"instagram\"\n        ]\n    },\n    \"start_time\": \"2026-06-01T00:00:00+0000\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "name": "EU desktop — clicks (updated)",
    "daily_budget": 4000
}

curl -X PUT 'https://api.endpointr.com/v1/marketing/ad-sets/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "name": "EU desktop — clicks (updated)",
    "daily_budget": 4000
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-sets/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "name": "EU desktop — clicks (updated)",
      "daily_budget": 4000
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-sets/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"name\": \"EU desktop — clicks (updated)\",\n    \"daily_budget\": 4000\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/marketing/ad-sets/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-sets/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-sets/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ad-accounts' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-accounts', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-accounts');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ad-accounts/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-accounts/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-accounts/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/creatives/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/creatives/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/creatives/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/creatives?account_id=%7B%7Bmeta_ad_account_id%7D%7D' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/creatives?account_id=%7B%7Bmeta_ad_account_id%7D%7D', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/creatives?account_id=%7B%7Bmeta_ad_account_id%7D%7D');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "account_id": "{{meta_ad_account_id}}",
    "name": "Spring landing creative",
    "object_story_spec": {
        "page_id": "0",
        "link_data": {
            "message": "Save 30% this week.",
            "link": "https://example.com/spring",
            "name": "Spring Sale",
            "call_to_action": {
                "type": "SHOP_NOW",
                "value": {
                    "link": "https://example.com/spring"
                }
            }
        }
    }
}

curl -X POST 'https://api.endpointr.com/v1/marketing/creatives' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "account_id": "{{meta_ad_account_id}}",
    "name": "Spring landing creative",
    "object_story_spec": {
        "page_id": "0",
        "link_data": {
            "message": "Save 30% this week.",
            "link": "https://example.com/spring",
            "name": "Spring Sale",
            "call_to_action": {
                "type": "SHOP_NOW",
                "value": {
                    "link": "https://example.com/spring"
                }
            }
        }
    }
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/creatives', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "account_id": "{{meta_ad_account_id}}",
      "name": "Spring landing creative",
      "object_story_spec": {
          "page_id": "0",
          "link_data": {
              "message": "Save 30% this week.",
              "link": "https://example.com/spring",
              "name": "Spring Sale",
              "call_to_action": {
                  "type": "SHOP_NOW",
                  "value": {
                      "link": "https://example.com/spring"
                  }
              }
          }
      }
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/creatives');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"account_id\": \"{{meta_ad_account_id}}\",\n    \"name\": \"Spring landing creative\",\n    \"object_story_spec\": {\n        \"page_id\": \"0\",\n        \"link_data\": {\n            \"message\": \"Save 30% this week.\",\n            \"link\": \"https://example.com/spring\",\n            \"name\": \"Spring Sale\",\n            \"call_to_action\": {\n                \"type\": \"SHOP_NOW\",\n                \"value\": {\n                    \"link\": \"https://example.com/spring\"\n                }\n            }\n        }\n    }\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/marketing/creatives/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/creatives/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/creatives/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ad-images?account_id=%7B%7Bmeta_ad_account_id%7D%7D' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-images?account_id=%7B%7Bmeta_ad_account_id%7D%7D', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-images?account_id=%7B%7Bmeta_ad_account_id%7D%7D');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "account_id": "{{meta_ad_account_id}}",
    "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
    "name": "spring-hero.png"
}

curl -X POST 'https://api.endpointr.com/v1/marketing/ad-images' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "account_id": "{{meta_ad_account_id}}",
    "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
    "name": "spring-hero.png"
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-images', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "account_id": "{{meta_ad_account_id}}",
      "image_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=",
      "name": "spring-hero.png"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-images');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"account_id\": \"{{meta_ad_account_id}}\",\n    \"image_base64\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkAAIAAAoAAv/lxKUAAAAASUVORK5CYII=\",\n    \"name\": \"spring-hero.png\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/marketing/ad-images/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-images/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-images/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ad-videos/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-videos/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-videos/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ad-videos?account_id=%7B%7Bmeta_ad_account_id%7D%7D' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-videos?account_id=%7B%7Bmeta_ad_account_id%7D%7D', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-videos?account_id=%7B%7Bmeta_ad_account_id%7D%7D');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "account_id": "{{meta_ad_account_id}}",
    "video_url": "https://example.com/marketing/spring-promo.mp4",
    "title": "Spring promo",
    "description": "Hero video — 15s vertical cut"
}

curl -X POST 'https://api.endpointr.com/v1/marketing/ad-videos' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "account_id": "{{meta_ad_account_id}}",
    "video_url": "https://example.com/marketing/spring-promo.mp4",
    "title": "Spring promo",
    "description": "Hero video — 15s vertical cut"
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-videos', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "account_id": "{{meta_ad_account_id}}",
      "video_url": "https://example.com/marketing/spring-promo.mp4",
      "title": "Spring promo",
      "description": "Hero video — 15s vertical cut"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-videos');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"account_id\": \"{{meta_ad_account_id}}\",\n    \"video_url\": \"https://example.com/marketing/spring-promo.mp4\",\n    \"title\": \"Spring promo\",\n    \"description\": \"Hero video — 15s vertical cut\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/marketing/ad-videos/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ad-videos/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ad-videos/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ads/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ads/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ads/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/ads?account_id=%7B%7Bmeta_ad_account_id%7D%7D' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ads?account_id=%7B%7Bmeta_ad_account_id%7D%7D', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ads?account_id=%7B%7Bmeta_ad_account_id%7D%7D');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "account_id": "{{meta_ad_account_id}}",
    "name": "Carousel — spring",
    "adset_id": "120000000000000",
    "creative_id": "120000000000000",
    "status": "PAUSED"
}

curl -X POST 'https://api.endpointr.com/v1/marketing/ads' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "account_id": "{{meta_ad_account_id}}",
    "name": "Carousel — spring",
    "adset_id": "120000000000000",
    "creative_id": "120000000000000",
    "status": "PAUSED"
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/ads', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "account_id": "{{meta_ad_account_id}}",
      "name": "Carousel — spring",
      "adset_id": "120000000000000",
      "creative_id": "120000000000000",
      "status": "PAUSED"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ads');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"account_id\": \"{{meta_ad_account_id}}\",\n    \"name\": \"Carousel — spring\",\n    \"adset_id\": \"120000000000000\",\n    \"creative_id\": \"120000000000000\",\n    \"status\": \"PAUSED\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "name": "Carousel — spring (v2)"
}

curl -X PUT 'https://api.endpointr.com/v1/marketing/ads/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "name": "Carousel — spring (v2)"
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/ads/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "name": "Carousel — spring (v2)"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ads/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"name\": \"Carousel — spring (v2)\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/marketing/ads/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/ads/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/ads/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/audiences/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/audiences/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/audiences/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/audiences?account_id=%7B%7Bmeta_ad_account_id%7D%7D' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/audiences?account_id=%7B%7Bmeta_ad_account_id%7D%7D', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/audiences?account_id=%7B%7Bmeta_ad_account_id%7D%7D');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "account_id": "{{meta_ad_account_id}}",
    "name": "Customers who purchased in last 30d",
    "subtype": "CUSTOM",
    "customer_file_source": "USER_PROVIDED_ONLY",
    "retention_days": 180
}

curl -X POST 'https://api.endpointr.com/v1/marketing/audiences' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "account_id": "{{meta_ad_account_id}}",
    "name": "Customers who purchased in last 30d",
    "subtype": "CUSTOM",
    "customer_file_source": "USER_PROVIDED_ONLY",
    "retention_days": 180
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/audiences', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "account_id": "{{meta_ad_account_id}}",
      "name": "Customers who purchased in last 30d",
      "subtype": "CUSTOM",
      "customer_file_source": "USER_PROVIDED_ONLY",
      "retention_days": 180
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/audiences');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"account_id\": \"{{meta_ad_account_id}}\",\n    \"name\": \"Customers who purchased in last 30d\",\n    \"subtype\": \"CUSTOM\",\n    \"customer_file_source\": \"USER_PROVIDED_ONLY\",\n    \"retention_days\": 180\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/marketing/audiences/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/audiences/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/audiences/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/auth?action=debug-token' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/auth?action=debug-token', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/auth?action=debug-token');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "action": "extend"
}

curl -X POST 'https://api.endpointr.com/v1/marketing/auth' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "action": "extend"
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/auth', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "action": "extend"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/auth');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"action\": \"extend\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/campaigns/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/campaigns/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/campaigns/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/campaigns?account_id=%7B%7Bmeta_ad_account_id%7D%7D&refresh=false' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/campaigns?account_id=%7B%7Bmeta_ad_account_id%7D%7D&refresh=false', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/campaigns?account_id=%7B%7Bmeta_ad_account_id%7D%7D&refresh=false');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "account_id": "{{meta_ad_account_id}}",
    "name": "Spring sale — search ads",
    "objective": "OUTCOME_TRAFFIC",
    "status": "PAUSED",
    "special_ad_categories": [],
    "daily_budget": 5000
}

curl -X POST 'https://api.endpointr.com/v1/marketing/campaigns' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "account_id": "{{meta_ad_account_id}}",
    "name": "Spring sale — search ads",
    "objective": "OUTCOME_TRAFFIC",
    "status": "PAUSED",
    "special_ad_categories": [],
    "daily_budget": 5000
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/campaigns', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "account_id": "{{meta_ad_account_id}}",
      "name": "Spring sale — search ads",
      "objective": "OUTCOME_TRAFFIC",
      "status": "PAUSED",
      "special_ad_categories": [],
      "daily_budget": 5000
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/campaigns');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"account_id\": \"{{meta_ad_account_id}}\",\n    \"name\": \"Spring sale — search ads\",\n    \"objective\": \"OUTCOME_TRAFFIC\",\n    \"status\": \"PAUSED\",\n    \"special_ad_categories\": [],\n    \"daily_budget\": 5000\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "name": "Spring sale — updated",
    "daily_budget": 7500
}

curl -X PUT 'https://api.endpointr.com/v1/marketing/campaigns/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "name": "Spring sale — updated",
    "daily_budget": 7500
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/campaigns/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "name": "Spring sale — updated",
      "daily_budget": 7500
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/campaigns/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"name\": \"Spring sale — updated\",\n    \"daily_budget\": 7500\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/marketing/campaigns/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/campaigns/:id', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/campaigns/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/catalogs/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/catalogs/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/catalogs/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/catalogs' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/catalogs', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/catalogs');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/insights?level=campaign&ids=120000000000000&date_preset=last_7d' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/insights?level=campaign&ids=120000000000000&date_preset=last_7d', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/insights?level=campaign&ids=120000000000000&date_preset=last_7d');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "level": "campaign",
    "ids": [
        "120000000000000",
        "120000000000001"
    ],
    "time_range": {
        "since": "2026-05-01",
        "until": "2026-05-21"
    },
    "breakdowns": [
        "age",
        "gender"
    ],
    "cached": true
}

curl -X POST 'https://api.endpointr.com/v1/marketing/insights' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "level": "campaign",
    "ids": [
        "120000000000000",
        "120000000000001"
    ],
    "time_range": {
        "since": "2026-05-01",
        "until": "2026-05-21"
    },
    "breakdowns": [
        "age",
        "gender"
    ],
    "cached": true
}'

const response = await fetch('https://api.endpointr.com/v1/marketing/insights', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "level": "campaign",
      "ids": [
          "120000000000000",
          "120000000000001"
      ],
      "time_range": {
          "since": "2026-05-01",
          "until": "2026-05-21"
      },
      "breakdowns": [
          "age",
          "gender"
      ],
      "cached": true
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/insights');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\n    \"level\": \"campaign\",\n    \"ids\": [\n        \"120000000000000\",\n        \"120000000000001\"\n    ],\n    \"time_range\": {\n        \"since\": \"2026-05-01\",\n        \"until\": \"2026-05-21\"\n    },\n    \"breakdowns\": [\n        \"age\",\n        \"gender\"\n    ],\n    \"cached\": true\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/leads/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/leads/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/leads/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/leads?form_id=120000000000000&created_after=2026-05-01' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/leads?form_id=120000000000000&created_after=2026-05-01', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/leads?form_id=120000000000000&created_after=2026-05-01');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/pages' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/pages', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/pages');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/marketing/pages/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/marketing/pages/:id', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/marketing/pages/:id');
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_JWT_TOKEN',
]);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);