{
    "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/payments/clearhaus-settlements' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/payments/clearhaus-settlements');
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/payments/clearhaus-settlements/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/payments/clearhaus-settlements/: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/payments/paypal-accounts' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-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/payments/paypal-balance' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-balance');
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/payments/paypal-plans/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-plans/: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/payments/paypal-plans?name=Pro&page_size=20' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/payments/paypal-plans?name=Pro&page_size=20', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-plans?name=Pro&page_size=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);

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

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

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-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/payments/paypal-invoices?status=UNPAID&page_size=20&total_required=true' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/payments/paypal-invoices?status=UNPAID&page_size=20&total_required=true', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-invoices?status=UNPAID&page_size=20&total_required=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);

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

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

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-overview');
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/payments/paypal-subscriptions/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-subscriptions/: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/payments/paypal-transactions?start_date=2026-06-01T00%3A00%3A00Z&end_date=2026-06-30T23%3A59%3A59Z&fields=all' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/payments/paypal-transactions?start_date=2026-06-01T00%3A00%3A00Z&end_date=2026-06-30T23%3A59%3A59Z&fields=all', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/payments/paypal-transactions?start_date=2026-06-01T00%3A00%3A00Z&end_date=2026-06-30T23%3A59%3A59Z&fields=all');
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/dinero-accounting-years' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-accounting-years');
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);

{
    "StartDate": "2026-01-01",
    "EndDate": "2026-12-31"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-accounting-years' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "StartDate": "2026-01-01",
    "EndDate": "2026-12-31"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-accounting-years', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "StartDate": "2026-01-01",
      "EndDate": "2026-12-31"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-accounting-years');
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    \"StartDate\": \"2026-01-01\",\n    \"EndDate\": \"2026-12-31\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-attachments/: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);

{
    "action": "add_file",
    "document_guid": "<doc-guid>",
    "file_guid": "<file-guid>",
    "file_name": "receipt.pdf"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-attachments' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "action": "add_file",
    "document_guid": "<doc-guid>",
    "file_guid": "<file-guid>",
    "file_name": "receipt.pdf"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-attachments', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "action": "add_file",
      "document_guid": "<doc-guid>",
      "file_guid": "<file-guid>",
      "file_name": "receipt.pdf"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-attachments');
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\": \"add_file\",\n    \"document_guid\": \"<doc-guid>\",\n    \"file_guid\": \"<file-guid>\",\n    \"file_name\": \"receipt.pdf\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/dinero-business-goals?year_key=%3Caccounting-year-key%3E' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-business-goals?year_key=%3Caccounting-year-key%3E', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-business-goals?year_key=%3Caccounting-year-key%3E');
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);

{
    "year_key": "<accounting-year-key>",
    "RevenueGoal": 1000000
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-business-goals' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "year_key": "<accounting-year-key>",
    "RevenueGoal": 1000000
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-business-goals', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "year_key": "<accounting-year-key>",
      "RevenueGoal": 1000000
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-business-goals');
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    \"year_key\": \"<accounting-year-key>\",\n    \"RevenueGoal\": 1000000\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-accounts?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);

{
    "action": "entry",
    "Name": "New revenue account",
    "AccountNumber": 1010
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-accounts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "action": "entry",
    "Name": "New revenue account",
    "AccountNumber": 1010
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-accounts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "action": "entry",
      "Name": "New revenue account",
      "AccountNumber": 1010
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-accounts');
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\": \"entry\",\n    \"Name\": \"New revenue account\",\n    \"AccountNumber\": 1010\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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/dinero-contacts?page=0&pageSize=100' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-contacts?page=0&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);

{
    "Name": "Acme ApS",
    "CountryKey": "DK",
    "Email": "billing@acme.dk",
    "IsPerson": false,
    "IsMember": false,
    "UseCvr": false
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-contacts' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "Name": "Acme ApS",
    "CountryKey": "DK",
    "Email": "billing@acme.dk",
    "IsPerson": false,
    "IsMember": false,
    "UseCvr": false
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-contacts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "Name": "Acme ApS",
      "CountryKey": "DK",
      "Email": "billing@acme.dk",
      "IsPerson": false,
      "IsMember": false,
      "UseCvr": false
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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    \"Name\": \"Acme ApS\",\n    \"CountryKey\": \"DK\",\n    \"Email\": \"billing@acme.dk\",\n    \"IsPerson\": false,\n    \"IsMember\": false,\n    \"UseCvr\": false\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "Name": "Acme ApS",
    "Email": "ap@acme.dk"
}

curl -X PUT 'https://api.endpointr.com/v1/accounting/dinero-contacts/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "Name": "Acme ApS",
    "Email": "ap@acme.dk"
}'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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    \"Name\": \"Acme ApS\",\n    \"Email\": \"ap@acme.dk\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-contacts/: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/accounting/dinero-countries' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-countries');
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/dinero-electronic-invoice?ean=5790000000000' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-electronic-invoice?ean=5790000000000');
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/dinero-entries?fromDate=2026-01-01&toDate=2026-12-31' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-entries?fromDate=2026-01-01&toDate=2026-12-31', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-entries?fromDate=2026-01-01&toDate=2026-12-31');
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/dinero-files/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-files/: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/dinero-files' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-files');
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 POST 'https://api.endpointr.com/v1/accounting/dinero-files' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '[]'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-files', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify([])
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-files');
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, '[]');
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-integrations');
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": "mobilepay_start"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-integrations' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "action": "mobilepay_start"
}'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-integrations');
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\": \"mobilepay_start\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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/dinero-invoices?page=0&pageSize=100&statusFilter=Booked' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-invoices?page=0&pageSize=100&statusFilter=Booked');
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);

{
    "ContactGuid": "<contact-guid>",
    "Currency": "DKK",
    "Language": "da-DK",
    "Date": "2026-01-15",
    "ProductLines": [
        {
            "BaseAmountValue": 1000,
            "Quantity": 1,
            "AccountNumber": 1000,
            "Unit": "parts",
            "Description": "Consulting",
            "LineType": "Product"
        }
    ]
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-invoices' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "ContactGuid": "<contact-guid>",
    "Currency": "DKK",
    "Language": "da-DK",
    "Date": "2026-01-15",
    "ProductLines": [
        {
            "BaseAmountValue": 1000,
            "Quantity": 1,
            "AccountNumber": 1000,
            "Unit": "parts",
            "Description": "Consulting",
            "LineType": "Product"
        }
    ]
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-invoices', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "ContactGuid": "<contact-guid>",
      "Currency": "DKK",
      "Language": "da-DK",
      "Date": "2026-01-15",
      "ProductLines": [
          {
              "BaseAmountValue": 1000,
              "Quantity": 1,
              "AccountNumber": 1000,
              "Unit": "parts",
              "Description": "Consulting",
              "LineType": "Product"
          }
      ]
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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    \"ContactGuid\": \"<contact-guid>\",\n    \"Currency\": \"DKK\",\n    \"Language\": \"da-DK\",\n    \"Date\": \"2026-01-15\",\n    \"ProductLines\": [\n        {\n            \"BaseAmountValue\": 1000,\n            \"Quantity\": 1,\n            \"AccountNumber\": 1000,\n            \"Unit\": \"parts\",\n            \"Description\": \"Consulting\",\n            \"LineType\": \"Product\"\n        }\n    ]\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "Timestamp": "<timestamp>",
    "ProductLines": []
}

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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    \"Timestamp\": \"<timestamp>\",\n    \"ProductLines\": []\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-invoices/: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);

[
    {
        "AccountNumber": 1000,
        "Amount": 1000,
        "BalancingAccountNumber": 55000,
        "Description": "Manual posting",
        "VoucherDate": "2026-01-15"
    }
]

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-ledger-items' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '[
    {
        "AccountNumber": 1000,
        "Amount": 1000,
        "BalancingAccountNumber": 55000,
        "Description": "Manual posting",
        "VoucherDate": "2026-01-15"
    }
]'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-ledger-items', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify([
      {
          "AccountNumber": 1000,
          "Amount": 1000,
          "BalancingAccountNumber": 55000,
          "Description": "Manual posting",
          "VoucherDate": "2026-01-15"
      }
  ])
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-ledger-items');
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    {\n        \"AccountNumber\": 1000,\n        \"Amount\": 1000,\n        \"BalancingAccountNumber\": 55000,\n        \"Description\": \"Manual posting\",\n        \"VoucherDate\": \"2026-01-15\"\n    }\n]");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-organizations');
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);

{
    "Name": "My Company ApS",
    "VatNumber": "12345678",
    "CountryKey": "DK"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-organizations' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "Name": "My Company ApS",
    "VatNumber": "12345678",
    "CountryKey": "DK"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-organizations', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "Name": "My Company ApS",
      "VatNumber": "12345678",
      "CountryKey": "DK"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-organizations');
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    \"Name\": \"My Company ApS\",\n    \"VatNumber\": \"12345678\",\n    \"CountryKey\": \"DK\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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/dinero-products?page=0&pageSize=100' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-products?page=0&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);

{
    "Name": "Consulting hour",
    "BaseAmountValue": 1000,
    "AccountNumber": 1000,
    "Unit": "hours",
    "Quantity": 1
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-products' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "Name": "Consulting hour",
    "BaseAmountValue": 1000,
    "AccountNumber": 1000,
    "Unit": "hours",
    "Quantity": 1
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-products', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "Name": "Consulting hour",
      "BaseAmountValue": 1000,
      "AccountNumber": 1000,
      "Unit": "hours",
      "Quantity": 1
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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    \"Name\": \"Consulting hour\",\n    \"BaseAmountValue\": 1000,\n    \"AccountNumber\": 1000,\n    \"Unit\": \"hours\",\n    \"Quantity\": 1\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "Name": "Consulting hour",
    "BaseAmountValue": 1200
}

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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    \"Name\": \"Consulting hour\",\n    \"BaseAmountValue\": 1200\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-products/: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/accounting/dinero-purchase-vouchers?id=%3Cpurchase-voucher-id%3E' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-purchase-vouchers?id=%3Cpurchase-voucher-id%3E', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-purchase-vouchers?id=%3Cpurchase-voucher-id%3E');
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);

{
    "id": "<purchase-voucher-id>",
    "Amount": 1250,
    "PaymentDate": "2026-01-20",
    "DepositAccountNumber": 55000
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-purchase-vouchers' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "id": "<purchase-voucher-id>",
    "Amount": 1250,
    "PaymentDate": "2026-01-20",
    "DepositAccountNumber": 55000
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-purchase-vouchers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "id": "<purchase-voucher-id>",
      "Amount": 1250,
      "PaymentDate": "2026-01-20",
      "DepositAccountNumber": 55000
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-purchase-vouchers');
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    \"id\": \"<purchase-voucher-id>\",\n    \"Amount\": 1250,\n    \"PaymentDate\": \"2026-01-20\",\n    \"DepositAccountNumber\": 55000\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/dinero-reports?report=result&year=2026' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-reports?report=result&year=2026', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-reports?report=result&year=2026');
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);

{
    "voucher_guid": "<voucher-guid>",
    "PhoneNumber": "+4512345678"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-sms' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "voucher_guid": "<voucher-guid>",
    "PhoneNumber": "+4512345678"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-sms', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "voucher_guid": "<voucher-guid>",
      "PhoneNumber": "+4512345678"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-sms');
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    \"voucher_guid\": \"<voucher-guid>\",\n    \"PhoneNumber\": \"+4512345678\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes/: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/dinero-sales-credit-notes?page=0&pageSize=100' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes?page=0&pageSize=100', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes?page=0&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);

{
    "ContactGuid": "<contact-guid>",
    "Currency": "DKK",
    "Date": "2026-01-15",
    "ProductLines": [
        {
            "BaseAmountValue": -500,
            "Quantity": 1,
            "AccountNumber": 1000,
            "Unit": "parts",
            "Description": "Refund"
        }
    ]
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "ContactGuid": "<contact-guid>",
    "Currency": "DKK",
    "Date": "2026-01-15",
    "ProductLines": [
        {
            "BaseAmountValue": -500,
            "Quantity": 1,
            "AccountNumber": 1000,
            "Unit": "parts",
            "Description": "Refund"
        }
    ]
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "ContactGuid": "<contact-guid>",
      "Currency": "DKK",
      "Date": "2026-01-15",
      "ProductLines": [
          {
              "BaseAmountValue": -500,
              "Quantity": 1,
              "AccountNumber": 1000,
              "Unit": "parts",
              "Description": "Refund"
          }
      ]
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes');
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    \"ContactGuid\": \"<contact-guid>\",\n    \"Currency\": \"DKK\",\n    \"Date\": \"2026-01-15\",\n    \"ProductLines\": [\n        {\n            \"BaseAmountValue\": -500,\n            \"Quantity\": 1,\n            \"AccountNumber\": 1000,\n            \"Unit\": \"parts\",\n            \"Description\": \"Refund\"\n        }\n    ]\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "Timestamp": "<timestamp>",
    "ProductLines": []
}

curl -X PUT 'https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "Timestamp": "<timestamp>",
    "ProductLines": []
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes/:id', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "Timestamp": "<timestamp>",
      "ProductLines": []
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes/: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    \"Timestamp\": \"<timestamp>\",\n    \"ProductLines\": []\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-sales-credit-notes/: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 POST 'https://api.endpointr.com/v1/accounting/dinero-settings' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '[]'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-settings', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify([])
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-settings');
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, '[]');
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-state-of-account/: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/dinero-state-of-account?id=%3Ccontact-guid%3E' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-state-of-account?id=%3Ccontact-guid%3E', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-state-of-account?id=%3Ccontact-guid%3E');
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);

{
    "id": "<contact-guid>",
    "Receiver": "ap@acme.dk"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-state-of-account' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "id": "<contact-guid>",
    "Receiver": "ap@acme.dk"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-state-of-account', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "id": "<contact-guid>",
      "Receiver": "ap@acme.dk"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-state-of-account');
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    \"id\": \"<contact-guid>\",\n    \"Receiver\": \"ap@acme.dk\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-trade-offers/: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/dinero-trade-offers?page=0&pageSize=100' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-trade-offers?page=0&pageSize=100', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-trade-offers?page=0&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);

{
    "ContactGuid": "<contact-guid>",
    "Currency": "DKK",
    "Date": "2026-01-15",
    "ProductLines": []
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-trade-offers' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "ContactGuid": "<contact-guid>",
    "Currency": "DKK",
    "Date": "2026-01-15",
    "ProductLines": []
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-trade-offers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "ContactGuid": "<contact-guid>",
      "Currency": "DKK",
      "Date": "2026-01-15",
      "ProductLines": []
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-trade-offers');
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    \"ContactGuid\": \"<contact-guid>\",\n    \"Currency\": \"DKK\",\n    \"Date\": \"2026-01-15\",\n    \"ProductLines\": []\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "ProductLines": []
}

curl -X PUT 'https://api.endpointr.com/v1/accounting/dinero-trade-offers/:id' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "ProductLines": []
}'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-trade-offers/: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    \"ProductLines\": []\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X DELETE 'https://api.endpointr.com/v1/accounting/dinero-trade-offers/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-trade-offers/: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/accounting/dinero-unified-vouchers?page=0&pageSize=100' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-unified-vouchers?page=0&pageSize=100', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-unified-vouchers?page=0&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);

curl -X GET 'https://api.endpointr.com/v1/accounting/dinero-vat-types' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-vat-types');
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/dinero-voucher-templates?action=types' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-voucher-templates?action=types');
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);

{
    "year_key": "<accounting-year-key>",
    "template_type": "manuel"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-voucher-templates' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "year_key": "<accounting-year-key>",
    "template_type": "manuel"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-voucher-templates', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "year_key": "<accounting-year-key>",
      "template_type": "manuel"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-voucher-templates');
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    \"year_key\": \"<accounting-year-key>\",\n    \"template_type\": \"manuel\"\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/accounting/dinero-vouchers?type=purchase&id=%3Cguid%3E' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-vouchers?type=purchase&id=%3Cguid%3E', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-vouchers?type=purchase&id=%3Cguid%3E');
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);

{
    "type": "purchase",
    "ContactGuid": "<supplier-guid>",
    "Date": "2026-01-15",
    "Lines": []
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-vouchers' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "type": "purchase",
    "ContactGuid": "<supplier-guid>",
    "Date": "2026-01-15",
    "Lines": []
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-vouchers', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "type": "purchase",
      "ContactGuid": "<supplier-guid>",
      "Date": "2026-01-15",
      "Lines": []
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-vouchers');
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    \"type\": \"purchase\",\n    \"ContactGuid\": \"<supplier-guid>\",\n    \"Date\": \"2026-01-15\",\n    \"Lines\": []\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

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

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

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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": "CreateSalesInvoice",
    "CallbackUrl": "https://example.com/hook"
}

curl -X POST 'https://api.endpointr.com/v1/accounting/dinero-webhooks' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "Event": "CreateSalesInvoice",
    "CallbackUrl": "https://example.com/hook"
}'

const response = await fetch('https://api.endpointr.com/v1/accounting/dinero-webhooks', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "Event": "CreateSalesInvoice",
      "CallbackUrl": "https://example.com/hook"
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/accounting/dinero-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\": \"CreateSalesInvoice\",\n    \"CallbackUrl\": \"https://example.com/hook\"\n}");
$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.customer.created",
    "action": "paypal.customer.create",
    "enabled": true,
    "mapping": {
        "email": "$.object.email",
        "name": "$.object.name",
        "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.customer.created",
    "action": "paypal.customer.create",
    "enabled": true,
    "mapping": {
        "email": "$.object.email",
        "name": "$.object.name",
        "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.customer.created",
      "action": "paypal.customer.create",
      "enabled": true,
      "mapping": {
          "email": "$.object.email",
          "name": "$.object.name",
          "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.customer.created\",\n    \"action\": \"paypal.customer.create\",\n    \"enabled\": true,\n    \"mapping\": {\n        \"email\": \"\$.object.email\",\n        \"name\": \"\$.object.name\",\n        \"external_reference\": \"\$.object.id\"\n    }\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

{
    "trigger_event": "stripe.customer.created",
    "action": "paypal.customer.create",
    "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.customer.created",
    "action": "paypal.customer.create",
    "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.customer.created",
      "action": "paypal.customer.create",
      "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.customer.created\",\n    \"action\": \"paypal.customer.create\",\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/calcom/cal-com-accounts' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/calcom/cal-com-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/calcom/cal-com-bookings/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/calcom/cal-com-bookings/: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/calcom/cal-com-bookings?status=upcoming&limit=10' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

const response = await fetch('https://api.endpointr.com/v1/calcom/cal-com-bookings?status=upcoming&limit=10', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  }
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/calcom/cal-com-bookings?status=upcoming&limit=10');
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);

{
    "start": "2026-08-13T09:00:00Z",
    "eventTypeId": 123,
    "attendee": {
        "name": "John Doe",
        "email": "john@example.com",
        "timeZone": "America/New_York"
    }
}

curl -X POST 'https://api.endpointr.com/v1/calcom/cal-com-bookings' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN' \
  -d '{
    "start": "2026-08-13T09:00:00Z",
    "eventTypeId": 123,
    "attendee": {
        "name": "John Doe",
        "email": "john@example.com",
        "timeZone": "America/New_York"
    }
}'

const response = await fetch('https://api.endpointr.com/v1/calcom/cal-com-bookings', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_JWT_TOKEN'
  },
  body: JSON.stringify({
      "start": "2026-08-13T09:00:00Z",
      "eventTypeId": 123,
      "attendee": {
          "name": "John Doe",
          "email": "john@example.com",
          "timeZone": "America/New_York"
      }
  })
});
const data = await response.json();

$ch = curl_init('https://api.endpointr.com/v1/calcom/cal-com-bookings');
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    \"start\": \"2026-08-13T09:00:00Z\",\n    \"eventTypeId\": 123,\n    \"attendee\": {\n        \"name\": \"John Doe\",\n        \"email\": \"john@example.com\",\n        \"timeZone\": \"America/New_York\"\n    }\n}");
$response = json_decode(curl_exec($ch), true);
curl_close($ch);

curl -X GET 'https://api.endpointr.com/v1/calcom/cal-com-event-types/:id' \
  -H 'Authorization: Bearer YOUR_JWT_TOKEN'

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

$ch = curl_init('https://api.endpointr.com/v1/calcom/cal-com-event-types/: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);