Camoo.Hosting Developer Portal

Reseller Platform API Reference

Automate your hosting and reseller infrastructure with the official Camoo.Hosting REST API. Provision domain registrations, administer DNS zones, configure client packages, and settle payments programmatically.

⚡

Base URL

https://api.camoo.hosting/v1

🔒

Authentication

Bearer <access_token>

📦

Request / Response

multipart/form-data → JSON

⏱️

Token Lifetime

30 Minutes

Quickstart Guide

Acquire your reseller credentials from your Camoo.Hosting account.
Exchange your credentials for a 30-minute JWT bearer token via POST /auth.
Send Authorization: Bearer <access_token> with every protected request.
Explore the endpoints below or try them live with the built-in test console.

Official PHP Client SDK: github.com/camoo/hosting. Need assistance? Contact Support.

Quick Overview POST

# 1. Authenticate
curl -X POST 'https://api.camoo.hosting/v1/auth' \
  -F '[email protected]' \
  -F 'password=your-password'

# 2. Make authenticated calls
curl -X POST 'https://api.camoo.hosting/v1/domains/availability' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'domain=example' \
  -F 'tlds=cm,net.cm'

POST https://api.camoo.hosting/v1/auth

Authentication

Authenticate reseller account credentials and obtain a JSON Web Token (JWT) access_token. This is the entrypoint to the Camoo Hosting API and the only endpoint that does not require an Authorization header.

Parameters

Parameter	Type	Required	Description
`email`	string	required	Reseller account email address.
`password`	string	required	Reseller account password.

Security Best Practice

Store credentials securely in environment variables; never hardcode credentials into client apps.
access_token remains valid for 30 minutes. Refresh prior to expiration to maintain seamless sessions.
Always pass the returned token via the standard HTTP header: Authorization: Bearer <access_token>.

curl -X POST 'https://api.camoo.hosting/v1/auth' \
  -F '[email protected]' \
  -F 'password=your-password'

const formData = new FormData();
formData.append('email', '[email protected]');
formData.append('password', 'your-password');

const response = await fetch('https://api.camoo.hosting/v1/auth', {
  method: 'POST',
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/auth"
data = {
    "email": "[email protected]",
    "password": "your-password"
}

response = requests.post(url, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/auth');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => [
        'email' => '[email protected]',
        'password' => 'your-password',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("email", "[email protected]")
	_ = writer.WriteField("password", "your-password")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/auth", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
  "status": "OK",
  "result": {
    "message": "Authentication successful",
    "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1aWQiOjM..."
  }
}

{
  "status": "KO",
  "result": {
    "message": "login failed"
  }
}

⚡ Try it out Interactive Test Console ›

email *

password *

POST https://api.camoo.hosting/v1/domains/availability

Check availability

Checks the availability of the specified domain name(s).

Parameters

Parameter	Type	Required	Description
`domain`	string	required	Domain name that you need to check the availability for. Without extension e.g: google
`tlds`	string	required	TLDs for which the domain name availability needs to be checked. For more than one, it should be separated with commas

curl -X POST 'https://api.camoo.hosting/v1/domains/availability' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'domain=example' \
  -F 'tlds=cm,net.cm'

const formData = new FormData();
formData.append('domain', 'example');
formData.append('tlds', 'cm,net.cm');

const response = await fetch('https://api.camoo.hosting/v1/domains/availability', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/availability"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "domain": "example",
    "tlds": "cm,net.cm"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/availability');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'domain' => 'example',
        'tlds' => 'cm,net.cm',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("domain", "example")
	_ = writer.WriteField("tlds", "cm,net.cm")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/availability", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "example.cm": {
            "classkey": "anticcm",
            "status": "N",
            "antic": true,
            "promo": [],
            "price": {
                "addtransferdomain": "7000",
                "restoredomain": "7000",
                "addnewdomain": "7000",
                "renewdomain": "7000"
            },
            "currency": "XAF"
        },
        "example.net.cm": {
            "classkey": "anticnetcm",
            "status": "Y",
            "antic": true,
            "promo": [],
            "price": {
                "addtransferdomain": "7000",
                "restoredomain": "7000",
                "addnewdomain": "7000",
                "renewdomain": "7000"
            },
            "currency": "XAF"
        }
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

domain *

tlds *

POST https://api.camoo.hosting/v1/domains/register

Register

Registers a domain name.

Note

A valid contact must be created first before registering a domain name.
Use POST /contacts/add to create registrant, administrative, technical, and billing contacts.
Provide the returned contact IDs for reg-contact-id, admin-contact-id, tech-contact-id, and billing-contact-id.

Parameters

Parameter	Type	Required	Description
`domain-name`	string	required	Domain name that you need to Register. e.g: example.cm
`years`	integer	required	Number of years for which you wish to Register this domain name.
`ns`	string	required	The Name Servers of the domain name.
`reg-contact-id`	integer	required	The Registrant Contact ID of the domain name (must be created first via POST /contacts/add).
`admin-contact-id`	integer	required	The Administrative Contact ID of the domain name (must be created first via POST /contacts/add).
`tech-contact-id`	integer	required	The Technical Contact ID of the domain name (must be created first via POST /contacts/add).
`billing-contact-id`	integer	required	The Billing Contact ID of the domain name (must be created first via POST /contacts/add).

curl -X POST 'https://api.camoo.hosting/v1/domains/register' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'domain-name=example.cm' \
  -F 'years=1' \
  -F 'ns=ns1.yourCompany.cm,ns2.yourCompany.cm' \
  -F 'reg-contact-id=1112' \
  -F 'admin-contact-id=1223' \
  -F 'billing-contact-id=1223' \
  -F 'tech-contact-id=1223'

const formData = new FormData();
formData.append('domain-name', 'example.cm');
formData.append('years', '1');
formData.append('ns', 'ns1.yourCompany.cm,ns2.yourCompany.cm');
formData.append('reg-contact-id', '1112');
formData.append('admin-contact-id', '1223');
formData.append('billing-contact-id', '1223');
formData.append('tech-contact-id', '1223');

const response = await fetch('https://api.camoo.hosting/v1/domains/register', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/register"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "domain-name": "example.cm",
    "years": "1",
    "ns": "ns1.yourCompany.cm,ns2.yourCompany.cm",
    "reg-contact-id": "1112",
    "admin-contact-id": "1223",
    "billing-contact-id": "1223",
    "tech-contact-id": "1223"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/register');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'domain-name' => 'example.cm',
        'years' => '1',
        'ns' => 'ns1.yourCompany.cm,ns2.yourCompany.cm',
        'reg-contact-id' => '1112',
        'admin-contact-id' => '1223',
        'billing-contact-id' => '1223',
        'tech-contact-id' => '1223',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("domain-name", "example.cm")
	_ = writer.WriteField("years", "1")
	_ = writer.WriteField("ns", "ns1.yourCompany.cm,ns2.yourCompany.cm")
	_ = writer.WriteField("reg-contact-id", "1112")
	_ = writer.WriteField("admin-contact-id", "1223")
	_ = writer.WriteField("billing-contact-id", "1223")
	_ = writer.WriteField("tech-contact-id", "1223")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/register", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": "38948498404",
        "domain": "example.cm",
        "message": "Domain registration completed Successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

domain-name *

years *

ns *

reg-contact-id *

admin-contact-id *

tech-contact-id *

billing-contact-id *

POST https://api.camoo.hosting/v1/domains/renew

Renew

Renews the specified Domain Registration Order for specified number of years.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Domain Id of the Domain Registration Order that you want to Renew.
`years`	integer	required	Number of years for which you want to Renew this Order.
`endtime`	integer	optional	Current Expiry Date of the Order in epoch time format.

curl -X POST 'https://api.camoo.hosting/v1/domains/renew' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=38948498404' \
  -F 'years=1' \
  -F 'endtime=1562912181'

const formData = new FormData();
formData.append('id', '38948498404');
formData.append('years', '1');
formData.append('endtime', '1562912181');

const response = await fetch('https://api.camoo.hosting/v1/domains/renew', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/renew"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "38948498404",
    "years": "1",
    "endtime": "1562912181"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/renew');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '38948498404',
        'years' => '1',
        'endtime' => '1562912181',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "38948498404")
	_ = writer.WriteField("years", "1")
	_ = writer.WriteField("endtime", "1562912181")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/renew", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "domain": "example.cm",
        "message": "Domain renew completed Successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

years *

endtime

POST https://api.camoo.hosting/v1/domains/suspend

Suspend

Applies the Suspension on the specified Domain. Type of request POST

Parameters

Parameter	Type	Required	Description
`id`	integer	required	domain ID for suspension

curl -X POST 'https://api.camoo.hosting/v1/domains/suspend' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=1234'

const formData = new FormData();
formData.append('id', '1234');

const response = await fetch('https://api.camoo.hosting/v1/domains/suspend', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/suspend"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "1234"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/suspend');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '1234',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "1234")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/suspend", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "domain": "example.cm",
        "message": "Domain suspension completed Successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/domains/unsuspend

Unsuspend

Removes the Suspension on the specified Domain. Type of request POST

Parameters

Parameter	Type	Required	Description
`id`	integer	required	domain ID

curl -X POST 'https://api.camoo.hosting/v1/domains/unsuspend' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=1234'

const formData = new FormData();
formData.append('id', '1234');

const response = await fetch('https://api.camoo.hosting/v1/domains/unsuspend', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/unsuspend"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "1234"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/unsuspend');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '1234',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "1234")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/unsuspend", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "domain": "example.cm",
        "message": "Domain unsuspended Successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/domains/validate-transfer

Is Transferable

Validating a Transfer Request

Parameters

Parameter	Type	Required	Description
`domain-name`	string	required	domain name you want to check.

curl -X POST 'https://api.camoo.hosting/v1/domains/validate-transfer' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'domain-name=example.cm'

const formData = new FormData();
formData.append('domain-name', 'example.cm');

const response = await fetch('https://api.camoo.hosting/v1/domains/validate-transfer', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/validate-transfer"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "domain-name": "example.cm"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/validate-transfer');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'domain-name' => 'example.cm',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("domain-name", "example.cm")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/validate-transfer", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": true
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

domain-name *

POST https://api.camoo.hosting/v1/domains/transfer

Transfer

Transfers a domain name.

Note

You need to ensure that the domain name is not Locked.

Parameters

Parameter	Type	Required	Description
`domain-name`	string	required	Domain name that you need to transfer. e.g: example.cm
`auth-code`	string	required	Authorization Code (EEP-code,Domain Secret, Auth Code) of the domain name that you want to transfer.
`years`	integer	required	Number of years for which you wish to transfer this domain name.
`ns`	string	required	The Name Servers of the domain name.
`reg-contact-id`	integer	required	The Registrant Contact of the domain name.
`admin-contact-id`	integer	required	The Administrative Contact of the domain name.
`tech-contact-id`	integer	required	The Technical Contact of the domain name.
`billing-contact-id`	integer	required	The Billing Contact of the domain name.

curl -X POST 'https://api.camoo.hosting/v1/domains/transfer' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'domain-name=example.cm' \
  -F 'auth-code=AKdo?dh-Ogh4' \
  -F 'years=1' \
  -F 'ns=ns1.yourCompany.com,ns2.yourCompany.com' \
  -F 'reg-contact-id=1112' \
  -F 'admin-contact-id=1223' \
  -F 'billing-contact-id=1223' \
  -F 'tech-contact-id=1223'

const formData = new FormData();
formData.append('domain-name', 'example.cm');
formData.append('auth-code', 'AKdo?dh-Ogh4');
formData.append('years', '1');
formData.append('ns', 'ns1.yourCompany.com,ns2.yourCompany.com');
formData.append('reg-contact-id', '1112');
formData.append('admin-contact-id', '1223');
formData.append('billing-contact-id', '1223');
formData.append('tech-contact-id', '1223');

const response = await fetch('https://api.camoo.hosting/v1/domains/transfer', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/transfer"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "domain-name": "example.cm",
    "auth-code": "AKdo?dh-Ogh4",
    "years": "1",
    "ns": "ns1.yourCompany.com,ns2.yourCompany.com",
    "reg-contact-id": "1112",
    "admin-contact-id": "1223",
    "billing-contact-id": "1223",
    "tech-contact-id": "1223"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/transfer');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'domain-name' => 'example.cm',
        'auth-code' => 'AKdo?dh-Ogh4',
        'years' => '1',
        'ns' => 'ns1.yourCompany.com,ns2.yourCompany.com',
        'reg-contact-id' => '1112',
        'admin-contact-id' => '1223',
        'billing-contact-id' => '1223',
        'tech-contact-id' => '1223',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("domain-name", "example.cm")
	_ = writer.WriteField("auth-code", "AKdo?dh-Ogh4")
	_ = writer.WriteField("years", "1")
	_ = writer.WriteField("ns", "ns1.yourCompany.com,ns2.yourCompany.com")
	_ = writer.WriteField("reg-contact-id", "1112")
	_ = writer.WriteField("admin-contact-id", "1223")
	_ = writer.WriteField("billing-contact-id", "1223")
	_ = writer.WriteField("tech-contact-id", "1223")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/transfer", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": "38948498406",
        "domain": "example.cm",
        "message": "Domain transfer queued Successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

domain-name *

auth-code *

years *

ns *

reg-contact-id *

admin-contact-id *

tech-contact-id *

billing-contact-id *

POST https://api.camoo.hosting/v1/domains/cm-whois

Whois CM

Makes a whois for .CM domains. Find out registrant information

Parameters

Parameter	Type	Required	Description
`domain-name`	string	required	domain name you want to check.

curl -X POST 'https://api.camoo.hosting/v1/domains/cm-whois' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'domain-name=example.cm'

const formData = new FormData();
formData.append('domain-name', 'example.cm');

const response = await fetch('https://api.camoo.hosting/v1/domains/cm-whois', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/cm-whois"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "domain-name": "example.cm"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/cm-whois');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'domain-name' => 'example.cm',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("domain-name", "example.cm")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/cm-whois", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": "TERMS OF USE ..."
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

domain-name *

GET https://api.camoo.hosting/v1/domains/details?id={id}

Get Domain details

Gets domain details By Id.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Domain's ID

curl -X GET 'https://api.camoo.hosting/v1/domains/details?id={id}' \
  -H 'Authorization: Bearer <access_token>'

const response = await fetch('https://api.camoo.hosting/v1/domains/details?id={id}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <access_token>'
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/details?id={id}"
headers = {
    "Authorization": "Bearer <access_token>"
}

response = requests.get(url, headers=headers)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/details?id={id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.camoo.hosting/v1/domains/details?id={id}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": 123,
        "domain-name": "yourDomain.cm",
        "years": 1,
        "created_at": "2016-05-03T17:46:23+01:00"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/domains/modify-nameservers

Modifying Name Servers

Modifies the nameservers associated with a specific domain registration order.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Identifier of the Domain Registration Order for which nameservers are to be modified.
`ns`	string	required	Comma-separated list of new nameservers for the domain. Requires at least two nameservers. Note Requires at least two nameservers. Example: "ns1.yourCompany.com,ns2.yourCompany.com"

curl -X POST 'https://api.camoo.hosting/v1/domains/modify-nameservers' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=123' \
  -F 'ns=ns1.yourCompany.com,ns2.yourCompany.com'

const formData = new FormData();
formData.append('id', '123');
formData.append('ns', 'ns1.yourCompany.com,ns2.yourCompany.com');

const response = await fetch('https://api.camoo.hosting/v1/domains/modify-nameservers', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/modify-nameservers"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "123",
    "ns": "ns1.yourCompany.com,ns2.yourCompany.com"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/modify-nameservers');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '123',
        'ns' => 'ns1.yourCompany.com,ns2.yourCompany.com',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "123")
	_ = writer.WriteField("ns", "ns1.yourCompany.com,ns2.yourCompany.com")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/modify-nameservers", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "message": "Nameservers for Domain ID123 have been successfully modified."
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

ns *

POST https://api.camoo.hosting/v1/domains/theft-protection/enable

Enabling the Theft Protection Lock

Applies the Theft Protection Lock on the specified domain registration order.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Identifier of the Domain Registration Order for which theft protection is to be modified.

curl -X POST 'https://api.camoo.hosting/v1/domains/theft-protection/enable' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=123'

const formData = new FormData();
formData.append('id', '123');

const response = await fetch('https://api.camoo.hosting/v1/domains/theft-protection/enable', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/theft-protection/enable"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "123"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/theft-protection/enable');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '123',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "123")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/theft-protection/enable", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "message": "Theft protection for Domain ID123 has been successfully enabled."
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/domains/theft-protection/disable

Disabling the Theft Protection Lock

Disables the Theft Protection Lock on the specified domain registration order.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Identifier of the Domain Registration Order on which the Theft Protection Lock is to be removed.

curl -X POST 'https://api.camoo.hosting/v1/domains/theft-protection/disable' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=123'

const formData = new FormData();
formData.append('id', '123');

const response = await fetch('https://api.camoo.hosting/v1/domains/theft-protection/disable', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/theft-protection/disable"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "123"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/theft-protection/disable');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '123',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "123")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/theft-protection/disable", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "message": "Theft protection for Domain ID123 has been successfully disabled."
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/domains/whois-privacy/enable

Enabling Whois Privacy

Enables the Whois Privacy Protection on the specified domain registration order.

Note

This service is not free.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Identifier of the Domain Registration Order for which Whois privacy protection is to be enabled.

curl -X POST 'https://api.camoo.hosting/v1/domains/whois-privacy/enable' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=123'

const formData = new FormData();
formData.append('id', '123');

const response = await fetch('https://api.camoo.hosting/v1/domains/whois-privacy/enable', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/whois-privacy/enable"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "123"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/whois-privacy/enable');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '123',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "123")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/whois-privacy/enable", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "message": "Whois privacy protection for Domain ID123 has been successfully enabled."
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/domains/whois-privacy/disable

Disabling Whois Privacy

Disables the Whois Privacy Protection on the specified domain registration order.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Identifier of the Domain Registration Order for which Whois privacy protection is to be disabled.

curl -X POST 'https://api.camoo.hosting/v1/domains/whois-privacy/disable' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=123'

const formData = new FormData();
formData.append('id', '123');

const response = await fetch('https://api.camoo.hosting/v1/domains/whois-privacy/disable', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/whois-privacy/disable"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "123"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/whois-privacy/disable');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '123',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "123")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/whois-privacy/disable", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "message": "Whois privacy protection for Domain ID123 has been successfully disabled."
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/domains/resend-verification-mail

Resend Verification Email

Resends the registrant verification email for the specified domain.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Identifier of the domain for which verification email is to be resent.

curl -X POST 'https://api.camoo.hosting/v1/domains/resend-verification-mail' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=123'

const formData = new FormData();
formData.append('id', '123');

const response = await fetch('https://api.camoo.hosting/v1/domains/resend-verification-mail', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/domains/resend-verification-mail"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "123"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/domains/resend-verification-mail');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '123',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "123")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/domains/resend-verification-mail", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "message": "Verification email resent successfully.",
        "success": true
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/contacts/add

Adding Contact

Adds a Contact to the domain using the details provided.

Parameters

Parameter	Type	Required	Description
`name`	string	required	Name of the Contact Note Max length 255 characters The Name should be complete first name and last name
`company`	string	required	Name of the Company Note If you don't have a company you should mention N/A or NA : Not Available or Not Applicable for this parameter.
`email`	string	required	Email address of the Contact
`address-1`	string	required	First line of address of the Contact
`city`	string	required	Name of the city
`ccode`	string	required	Country code as per ISO 3166-1 alpha-2
`zipcode`	string	required	Zip Code
`phone-cc`	integer	required	Telephone number country code Note Between 1-3 digits
`phone`	integer	required	Telephone number Note Between 4-12 digits
`state`	string	required	Name of the State
`address-2`	string	optional	second line of address of the Contact
`address-3`	string	optional	Third line of address of the Contact
`fax-cc`	integer	optional	Fax number country code Note Between 1-3 digits
`fax`	integer	optional	Fax number Note Between 4-12 digits
`customer-id`	integer	optional	The Customer under whom you want to create the Contact

curl -X POST 'https://api.camoo.hosting/v1/contacts/add' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'name=John Doe' \
  -F 'company=Doe Ltd.' \
  -F '[email protected]' \
  -F 'address-1=Bastos' \
  -F 'city=Yaounde' \
  -F 'ccode=CM' \
  -F 'zipcode=0000' \
  -F 'phone-cc=237' \
  -F 'phone=612345689' \
  -F 'state=Centre'

const formData = new FormData();
formData.append('name', 'John Doe');
formData.append('company', 'Doe Ltd.');
formData.append('email', '[email protected]');
formData.append('address-1', 'Bastos');
formData.append('city', 'Yaounde');
formData.append('ccode', 'CM');
formData.append('zipcode', '0000');
formData.append('phone-cc', '237');
formData.append('phone', '612345689');
formData.append('state', 'Centre');

const response = await fetch('https://api.camoo.hosting/v1/contacts/add', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/contacts/add"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "name": "John Doe",
    "company": "Doe Ltd.",
    "email": "[email protected]",
    "address-1": "Bastos",
    "city": "Yaounde",
    "ccode": "CM",
    "zipcode": "0000",
    "phone-cc": "237",
    "phone": "612345689",
    "state": "Centre"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/contacts/add');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'name' => 'John Doe',
        'company' => 'Doe Ltd.',
        'email' => '[email protected]',
        'address-1' => 'Bastos',
        'city' => 'Yaounde',
        'ccode' => 'CM',
        'zipcode' => '0000',
        'phone-cc' => '237',
        'phone' => '612345689',
        'state' => 'Centre',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("name", "John Doe")
	_ = writer.WriteField("company", "Doe Ltd.")
	_ = writer.WriteField("email", "[email protected]")
	_ = writer.WriteField("address-1", "Bastos")
	_ = writer.WriteField("city", "Yaounde")
	_ = writer.WriteField("ccode", "CM")
	_ = writer.WriteField("zipcode", "0000")
	_ = writer.WriteField("phone-cc", "237")
	_ = writer.WriteField("phone", "612345689")
	_ = writer.WriteField("state", "Centre")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/contacts/add", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": "2334"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

name *

company *

email *

address-1 *

city *

ccode *

zipcode *

phone-cc *

phone *

state *

address-2

address-3

fax-cc

fax

customer-id

POST https://api.camoo.hosting/v1/contacts/edit

Modify Contact

Modifies the details of an existing Contact.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Contact / Identity ID to modify
`name`	string	optional	Name of the Contact Note Max length 255 characters complete first name and last name
`company`	string	optional	Name of the Company
`email`	string	optional	Email address of the Contact
`address-1`	string	optional	First line of address of the Contact
`city`	string	optional	Name of the city
`ccode`	string	optional	Country code as per ISO 3166-1 alpha-2
`zipcode`	string	optional	Zip Code
`phone-cc`	integer	optional	Telephone number country code
`phone`	integer	optional	Telephone number
`state`	string	optional	Name of the State
`address-2`	string	optional	Second line of address of the Contact
`address-3`	string	optional	Third line of address of the Contact
`fax-cc`	integer	optional	Fax number country code
`fax`	integer	optional	Fax number

curl -X POST 'https://api.camoo.hosting/v1/contacts/edit' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=2334' \
  -F 'name=John Doe Updated' \
  -F 'company=Doe Ltd.' \
  -F '[email protected]' \
  -F 'address-1=Bastos' \
  -F 'city=Yaounde' \
  -F 'ccode=CM' \
  -F 'zipcode=0000' \
  -F 'phone-cc=237' \
  -F 'phone=612345689' \
  -F 'state=Centre'

const formData = new FormData();
formData.append('id', '2334');
formData.append('name', 'John Doe Updated');
formData.append('company', 'Doe Ltd.');
formData.append('email', '[email protected]');
formData.append('address-1', 'Bastos');
formData.append('city', 'Yaounde');
formData.append('ccode', 'CM');
formData.append('zipcode', '0000');
formData.append('phone-cc', '237');
formData.append('phone', '612345689');
formData.append('state', 'Centre');

const response = await fetch('https://api.camoo.hosting/v1/contacts/edit', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/contacts/edit"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "2334",
    "name": "John Doe Updated",
    "company": "Doe Ltd.",
    "email": "[email protected]",
    "address-1": "Bastos",
    "city": "Yaounde",
    "ccode": "CM",
    "zipcode": "0000",
    "phone-cc": "237",
    "phone": "612345689",
    "state": "Centre"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/contacts/edit');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '2334',
        'name' => 'John Doe Updated',
        'company' => 'Doe Ltd.',
        'email' => '[email protected]',
        'address-1' => 'Bastos',
        'city' => 'Yaounde',
        'ccode' => 'CM',
        'zipcode' => '0000',
        'phone-cc' => '237',
        'phone' => '612345689',
        'state' => 'Centre',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "2334")
	_ = writer.WriteField("name", "John Doe Updated")
	_ = writer.WriteField("company", "Doe Ltd.")
	_ = writer.WriteField("email", "[email protected]")
	_ = writer.WriteField("address-1", "Bastos")
	_ = writer.WriteField("city", "Yaounde")
	_ = writer.WriteField("ccode", "CM")
	_ = writer.WriteField("zipcode", "0000")
	_ = writer.WriteField("phone-cc", "237")
	_ = writer.WriteField("phone", "612345689")
	_ = writer.WriteField("state", "Centre")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/contacts/edit", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": 2334,
        "message": "Contact modified successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

name

company

email

address-1

city

ccode

zipcode

phone-cc

phone

state

address-2

address-3

fax-cc

fax

POST https://api.camoo.hosting/v1/customers/add

Adding Customer

Creates a Customer Account using the details provided.

Parameters

Parameter	Type	Required	Description
`name`	string	required	Name of the Customer Note Max length 255 characters The Name should be complete first name and last name
`company`	string	required	Name of the Company Note If you don't have a company you should mention N/A or NA : Not Available or Not Applicable for this parameter.
`email`	string	required	Email address of the Customer
`address-1`	string	required	First line of address of the Customer
`city`	string	required	Name of the city
`ccode`	string	required	Country code as per ISO 3166-1 alpha-2
`zipcode`	string	required	Zip Code
`phone-cc`	integer	required	Telephone number country code Note Between 1-3 digits
`phone`	integer	required	Telephone number Note Between 4-12 digits
`lang-pref`	string	optional	Language Code as per ISO Note e.g. fr_FR or en_GB
`state`	string	required	Name of the State
`address-2`	string	optional	second line of address of the Customer
`address-3`	string	optional	Third line of address of the Customer
`fax-cc`	integer	optional	Fax number country code Note Between 1-3 digits
`fax`	integer	optional	Fax number Note Between 4-12 digits
`terms`	boolean	optional	Accept Terms and Conditions and Privacy Policy to create an account
`password`	string	optional	Sets login Password for the customer Note Password should contain at least 8 characters 1 uppercase 1 lowercase 1 digits and 1 special character
`password_confirm`	string	optional	Required if Password is set. It should be the same value as Password

curl -X POST 'https://api.camoo.hosting/v1/customers/add' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'name=John Doe' \
  -F 'company=Doe Ltd.' \
  -F '[email protected]' \
  -F 'address-1=Bastos' \
  -F 'city=Yaounde' \
  -F 'ccode=CM' \
  -F 'terms=1' \
  -F 'lang-pref=fr_FR' \
  -F 'zipcode=0000' \
  -F 'phone-cc=237' \
  -F 'phone=612345689' \
  -F 'state=Centre' \
  -F 'password=TopSecre!Passwd' \
  -F 'password_confirm=TopSecre!Passwd'

const formData = new FormData();
formData.append('name', 'John Doe');
formData.append('company', 'Doe Ltd.');
formData.append('email', '[email protected]');
formData.append('address-1', 'Bastos');
formData.append('city', 'Yaounde');
formData.append('ccode', 'CM');
formData.append('terms', '1');
formData.append('lang-pref', 'fr_FR');
formData.append('zipcode', '0000');
formData.append('phone-cc', '237');
formData.append('phone', '612345689');
formData.append('state', 'Centre');
formData.append('password', 'TopSecre!Passwd');
formData.append('password_confirm', 'TopSecre!Passwd');

const response = await fetch('https://api.camoo.hosting/v1/customers/add', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/customers/add"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "name": "John Doe",
    "company": "Doe Ltd.",
    "email": "[email protected]",
    "address-1": "Bastos",
    "city": "Yaounde",
    "ccode": "CM",
    "terms": "1",
    "lang-pref": "fr_FR",
    "zipcode": "0000",
    "phone-cc": "237",
    "phone": "612345689",
    "state": "Centre",
    "password": "TopSecre!Passwd",
    "password_confirm": "TopSecre!Passwd"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/customers/add');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'name' => 'John Doe',
        'company' => 'Doe Ltd.',
        'email' => '[email protected]',
        'address-1' => 'Bastos',
        'city' => 'Yaounde',
        'ccode' => 'CM',
        'terms' => '1',
        'lang-pref' => 'fr_FR',
        'zipcode' => '0000',
        'phone-cc' => '237',
        'phone' => '612345689',
        'state' => 'Centre',
        'password' => 'TopSecre!Passwd',
        'password_confirm' => 'TopSecre!Passwd',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("name", "John Doe")
	_ = writer.WriteField("company", "Doe Ltd.")
	_ = writer.WriteField("email", "[email protected]")
	_ = writer.WriteField("address-1", "Bastos")
	_ = writer.WriteField("city", "Yaounde")
	_ = writer.WriteField("ccode", "CM")
	_ = writer.WriteField("terms", "1")
	_ = writer.WriteField("lang-pref", "fr_FR")
	_ = writer.WriteField("zipcode", "0000")
	_ = writer.WriteField("phone-cc", "237")
	_ = writer.WriteField("phone", "612345689")
	_ = writer.WriteField("state", "Centre")
	_ = writer.WriteField("password", "TopSecre!Passwd")
	_ = writer.WriteField("password_confirm", "TopSecre!Passwd")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/customers/add", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": "123"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

name *

company *

email *

address-1 *

city *

ccode *

zipcode *

phone-cc *

phone *

lang-pref

state *

address-2

address-3

fax-cc

fax

terms

password

password_confirm

POST https://api.camoo.hosting/v1/customers/edit

Modify Customer

Modifies the details of an existing Reseller Customer.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Customer ID to modify
`name`	string	optional	Name of the Customer
`company`	string	optional	Name of the Company
`email`	string	optional	Email address of the Customer
`lang-pref`	string	optional	Language Preference (fr_FR or en_GB)

curl -X POST 'https://api.camoo.hosting/v1/customers/edit' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=123' \
  -F 'name=John Doe Updated' \
  -F 'company=Doe Ltd.' \
  -F '[email protected]' \
  -F 'lang-pref=fr_FR'

const formData = new FormData();
formData.append('id', '123');
formData.append('name', 'John Doe Updated');
formData.append('company', 'Doe Ltd.');
formData.append('email', '[email protected]');
formData.append('lang-pref', 'fr_FR');

const response = await fetch('https://api.camoo.hosting/v1/customers/edit', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/customers/edit"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "123",
    "name": "John Doe Updated",
    "company": "Doe Ltd.",
    "email": "[email protected]",
    "lang-pref": "fr_FR"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/customers/edit');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '123',
        'name' => 'John Doe Updated',
        'company' => 'Doe Ltd.',
        'email' => '[email protected]',
        'lang-pref' => 'fr_FR',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "123")
	_ = writer.WriteField("name", "John Doe Updated")
	_ = writer.WriteField("company", "Doe Ltd.")
	_ = writer.WriteField("email", "[email protected]")
	_ = writer.WriteField("lang-pref", "fr_FR")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/customers/edit", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": 123,
        "message": "Customer modified successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

name

company

email

lang-pref

GET https://api.camoo.hosting/v1/customers/get-by-id?id={id}

Get Customer By Id

Gets Reseller Customer By Id.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Customer's ID

curl -X GET 'https://api.camoo.hosting/v1/customers/get-by-id?id={id}' \
  -H 'Authorization: Bearer <access_token>'

const response = await fetch('https://api.camoo.hosting/v1/customers/get-by-id?id={id}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <access_token>'
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/customers/get-by-id?id={id}"
headers = {
    "Authorization": "Bearer <access_token>"
}

response = requests.get(url, headers=headers)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/customers/get-by-id?id={id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.camoo.hosting/v1/customers/get-by-id?id={id}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": 123,
        "username": "[email protected]",
        "identities": [
            {
                "id": 1960,
                "email": "[email protected]",
                "name": "John Doe",
                "company": "Doe Ltd.",
                "...": "..."
            }
        ]
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

GET https://api.camoo.hosting/v1/customers/get-by-email?email={email}

Get Customer By E-mail

Gets Reseller Customer By Email.

Parameters

Parameter	Type	Required	Description
`email`	string	required	Customer's Email

curl -X GET 'https://api.camoo.hosting/v1/customers/get-by-email?email={email}' \
  -H 'Authorization: Bearer <access_token>'

const response = await fetch('https://api.camoo.hosting/v1/customers/get-by-email?email={email}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <access_token>'
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/customers/get-by-email?email={email}"
headers = {
    "Authorization": "Bearer <access_token>"
}

response = requests.get(url, headers=headers)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/customers/get-by-email?email={email}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.camoo.hosting/v1/customers/get-by-email?email={email}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": 123,
        "username": "[email protected]",
        "identities": [
            {
                "id": 1960,
                "email": "[email protected]",
                "name": "John Doe",
                "company": "Doe Ltd.",
                "...": "..."
            }
        ]
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

email *

GET https://api.camoo.hosting/v1/customers/sso?id={id}

Get SSO Token By Id

Gets Reseller Customer SSO Token By Id.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Customer's ID

curl -X GET 'https://api.camoo.hosting/v1/customers/sso?id={id}' \
  -H 'Authorization: Bearer <access_token>'

const response = await fetch('https://api.camoo.hosting/v1/customers/sso?id={id}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <access_token>'
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/customers/sso?id={id}"
headers = {
    "Authorization": "Bearer <access_token>"
}

response = requests.get(url, headers=headers)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/customers/sso?id={id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.camoo.hosting/v1/customers/sso?id={id}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "sso_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/customers/auth

Customer Authentication

Authenticates a reseller customer with email and password.

Parameters

Parameter	Type	Required	Description
`email`	string	required	Customer account email
`password`	string	required	Customer login password

curl -X POST 'https://api.camoo.hosting/v1/customers/auth' \
  -H 'Authorization: Bearer <access_token>' \
  -F '[email protected]' \
  -F 'password=CustomerPasswd!2026'

const formData = new FormData();
formData.append('email', '[email protected]');
formData.append('password', 'CustomerPasswd!2026');

const response = await fetch('https://api.camoo.hosting/v1/customers/auth', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/customers/auth"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "email": "[email protected]",
    "password": "CustomerPasswd!2026"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/customers/auth');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'email' => '[email protected]',
        'password' => 'CustomerPasswd!2026',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("email", "[email protected]")
	_ = writer.WriteField("password", "CustomerPasswd!2026")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/customers/auth", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": 123,
        "username": "[email protected]",
        "identities": [
            {
                "id": 1960,
                "email": "[email protected]",
                "name": "John Doe"
            }
        ]
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

email *

password *

GET https://api.camoo.hosting/v1/customers/balance?id={id}

Get Customer Balance

Gets the account balance and unpaid invoice totals for a specific reseller customer.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Reseller customer identifier.
`currency`	string	optional	Currency code for the balance (default: XAF).

curl -X GET 'https://api.camoo.hosting/v1/customers/balance?id={id}' \
  -H 'Authorization: Bearer <access_token>'

const response = await fetch('https://api.camoo.hosting/v1/customers/balance?id={id}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <access_token>'
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/customers/balance?id={id}"
headers = {
    "Authorization": "Bearer <access_token>"
}

response = requests.get(url, headers=headers)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/customers/balance?id={id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.camoo.hosting/v1/customers/balance?id={id}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "customer_id": 123,
        "username": "[email protected]",
        "balance": 15000,
        "currency": "XAF",
        "unpaid_amount": 0
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

currency

POST https://api.camoo.hosting/v1/sub-domains/add

Adding Sub-domain

Adds a subdomain to a domain using the details provided.

Parameters

Parameter	Type	Required	Description
`name`	string	required	Hostname label for the subdomain. Note Max length 63 characters
`domain-name`	string	required	Parent domain under which the subdomain will be created.
`target`	string	required	The target folder on the web space. If given target does not exist, the folder is created. Note The folder is/should be created under /home/user/<b>target</b>

curl -X POST 'https://api.camoo.hosting/v1/sub-domains/add' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'name=dev' \
  -F 'domain-name=example.cm' \
  -F 'target=dev-folder'

const formData = new FormData();
formData.append('name', 'dev');
formData.append('domain-name', 'example.cm');
formData.append('target', 'dev-folder');

const response = await fetch('https://api.camoo.hosting/v1/sub-domains/add', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/sub-domains/add"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "name": "dev",
    "domain-name": "example.cm",
    "target": "dev-folder"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/sub-domains/add');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'name' => 'dev',
        'domain-name' => 'example.cm',
        'target' => 'dev-folder',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("name", "dev")
	_ = writer.WriteField("domain-name", "example.cm")
	_ = writer.WriteField("target", "dev-folder")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/sub-domains/add", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "id": "1234",
        "message": "Subdomain created successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

name *

domain-name *

target *

POST https://api.camoo.hosting/v1/sub-domains/delete

Delete Sub-domain

Deletes a subdomain using its identifier.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Sub domain ID

curl -X POST 'https://api.camoo.hosting/v1/sub-domains/delete' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=1234'

const formData = new FormData();
formData.append('id', '1234');

const response = await fetch('https://api.camoo.hosting/v1/sub-domains/delete', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/sub-domains/delete"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "1234"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/sub-domains/delete');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '1234',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "1234")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/sub-domains/delete", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "message": "Subdomain deleted successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/dns/activate

Activate

Activates the DNS service for a domain.

Parameters

Parameter	Type	Required	Description
`id`	integer	required	Domain ID that you need to activate our DNS service.

curl -X POST 'https://api.camoo.hosting/v1/dns/activate' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'id=1234'

const formData = new FormData();
formData.append('id', '1234');

const response = await fetch('https://api.camoo.hosting/v1/dns/activate', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/dns/activate"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "id": "1234"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/dns/activate');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'id' => '1234',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("id", "1234")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/dns/activate", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "zone_id": 123,
        "message": "DNS service activated successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

id *

POST https://api.camoo.hosting/v1/dns/add-record

Add Record

Adds a DNS record to an active DNS zone.

Parameters

Parameter	Type	Required	Description
`zone_id`	integer	required	Zone ID for which you want to add the record
`value`	string	required	A Fully Qualified Domain Name (FQDN) as the destination
`type`	string	required	Type of record you want to add Note Allowed types are: 'A' 'AAAA' 'CNAME' 'NS' 'MX' 'TXT' 'SVR' 'SOA'
`host`	string	optional	The host part of the domain name for which you need to add a record Note For record with @ host should be empty
`ttl`	integer	optional	Number of seconds the record needs to be cached by the DNS Resolvers. Default value is 14400.
`priority`	integer	optional	The Priority of the host/record. Value ranges from 0 to 65535. Note relevant only for MX and SRV records
`port`	integer	optional	The port number of the service Note relevant only for SRV records
`weight`	integer	optional	A relative weight for records with the same priority Note relevant only for SRV records

curl -X POST 'https://api.camoo.hosting/v1/dns/add-record' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'zone_id=1234' \
  -F 'host=www' \
  -F 'type=cname' \
  -F 'value=example.cm'

const formData = new FormData();
formData.append('zone_id', '1234');
formData.append('host', 'www');
formData.append('type', 'cname');
formData.append('value', 'example.cm');

const response = await fetch('https://api.camoo.hosting/v1/dns/add-record', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/dns/add-record"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "zone_id": "1234",
    "host": "www",
    "type": "cname",
    "value": "example.cm"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/dns/add-record');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'zone_id' => '1234',
        'host' => 'www',
        'type' => 'cname',
        'value' => 'example.cm',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("zone_id", "1234")
	_ = writer.WriteField("host", "www")
	_ = writer.WriteField("type", "cname")
	_ = writer.WriteField("value", "example.cm")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/dns/add-record", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "record_id": 123,
        "message": "DNS record created successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

zone_id *

value *

type *

host

ttl

priority

port

weight

POST https://api.camoo.hosting/v1/dns/delete-record

Delete Record

Deletes a DNS record from a zone.

Parameters

Parameter	Type	Required	Description
`zone_id`	integer	required	Zone ID under which the record exists
`record_id`	integer	required	Record ID that you want to delete.

curl -X POST 'https://api.camoo.hosting/v1/dns/delete-record' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'zone_id=123' \
  -F 'record_id=144'

const formData = new FormData();
formData.append('zone_id', '123');
formData.append('record_id', '144');

const response = await fetch('https://api.camoo.hosting/v1/dns/delete-record', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/dns/delete-record"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "zone_id": "123",
    "record_id": "144"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/dns/delete-record');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'zone_id' => '123',
        'record_id' => '144',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("zone_id", "123")
	_ = writer.WriteField("record_id", "144")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/dns/delete-record", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "zone_id": 123,
        "message": "DNS record deleted successfully"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

zone_id *

record_id *

GET https://api.camoo.hosting/v1/tariffs/get?count={count}&page={page}

Get All tariffs

Gets all tariffs for an Account.

Parameters

Parameter	Type	Required	Description
`count`	integer	optional	This parameter lets you specify the amount of tariffs to return in your API call. The default for this parameter (if it isn't specified) is 20 tariffs. The maximum amount of tariffs you can have returned to you via this parameter is 100.
`page`	integer	optional	Used to page through the tariffs. Every call to this endpoint will return a has_more key with a bool value. If this value is true, then send {page} +1 to get the next page of tariffs.

curl -X GET 'https://api.camoo.hosting/v1/tariffs/get?count={count}&page={page}' \
  -H 'Authorization: Bearer <access_token>'

const response = await fetch('https://api.camoo.hosting/v1/tariffs/get?count={count}&page={page}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <access_token>'
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/tariffs/get?count={count}&page={page}"
headers = {
    "Authorization": "Bearer <access_token>"
}

response = requests.get(url, headers=headers)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/tariffs/get?count={count}&page={page}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.camoo.hosting/v1/tariffs/get?count={count}&page={page}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": [
        {
            "tariffs": [
                {
                    "id": 123,
                    "...": "..."
                }
            ],
            "has_more": true
        }
    ]
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

count

page

POST https://api.camoo.hosting/v1/payment/mobile-money

Mobile money payment

Starts a mobile money payment for a reseller customer.

Parameters

Parameter	Type	Required	Description
`phoneNumber`	string	required	Customer mobile number in international format.
`amount`	number	required	Amount to charge in the account currency.
`customer`	integer	required	Reseller customer identifier.

curl -X POST 'https://api.camoo.hosting/v1/payment/mobile-money' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'phoneNumber=+237600000000' \
  -F 'amount=5000' \
  -F 'customer=1234'

const formData = new FormData();
formData.append('phoneNumber', '+237600000000');
formData.append('amount', '5000');
formData.append('customer', '1234');

const response = await fetch('https://api.camoo.hosting/v1/payment/mobile-money', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/payment/mobile-money"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "phoneNumber": "+237600000000",
    "amount": "5000",
    "customer": "1234"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/payment/mobile-money');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'phoneNumber' => '+237600000000',
        'amount' => '5000',
        'customer' => '1234',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("phoneNumber", "+237600000000")
	_ = writer.WriteField("amount", "5000")
	_ = writer.WriteField("customer", "1234")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/payment/mobile-money", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "paymentId": "payment-reference",
        "time": 1700000000,
        "message": "in progress",
        "success": true
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

phoneNumber *

amount *

customer *

GET https://api.camoo.hosting/v1/payment/check?payment_id={payment_id}

Check mobile money payment

Checks whether a mobile money payment has been completed.

Parameters

Parameter	Type	Required	Description
`payment_id`	string	required	Payment reference returned by the payment request.

curl -X GET 'https://api.camoo.hosting/v1/payment/check?payment_id={payment_id}' \
  -H 'Authorization: Bearer <access_token>'

const response = await fetch('https://api.camoo.hosting/v1/payment/check?payment_id={payment_id}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer <access_token>'
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/payment/check?payment_id={payment_id}"
headers = {
    "Authorization": "Bearer <access_token>"
}

response = requests.get(url, headers=headers)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/payment/check?payment_id={payment_id}');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'GET',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.camoo.hosting/v1/payment/check?payment_id={payment_id}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "success": true
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

payment_id *

POST https://api.camoo.hosting/v1/order/offline

Create offline order

Creates an order to be settled offline.

Parameters

Parameter	Type	Required	Description
`body`	string	required	JSON-encoded cart containing at least the reseller customer identifier in the user field.

curl -X POST 'https://api.camoo.hosting/v1/order/offline' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'body={"user":1234,"items":[]}'

const formData = new FormData();
formData.append('body', '{"user":1234,"items":[]}');

const response = await fetch('https://api.camoo.hosting/v1/order/offline', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/order/offline"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "body": "{\"user\":1234,\"items\":[]}"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/order/offline');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'body' => '{"user":1234,"items":[]}',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("body", "{\"user\":1234,\"items\":[]}")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/order/offline", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "success": true
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

body *

POST https://api.camoo.hosting/v1/order/online

Create online order

Creates an order after a completed online payment.

Parameters

Parameter	Type	Required	Description
`body`	string	required	JSON-encoded cart containing user and payment_id fields.

curl -X POST 'https://api.camoo.hosting/v1/order/online' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'body={"user":1234,"payment_id":"payment-reference","items":[]}'

const formData = new FormData();
formData.append('body', '{"user":1234,"payment_id":"payment-reference","items":[]}');

const response = await fetch('https://api.camoo.hosting/v1/order/online', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/order/online"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "body": "{\"user\":1234,\"payment_id\":\"payment-reference\",\"items\":[]}"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/order/online');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'body' => '{"user":1234,"payment_id":"payment-reference","items":[]}',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("body", "{\"user\":1234,\"payment_id\":\"payment-reference\",\"items\":[]}")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/order/online", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "success": true
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

body *

POST https://api.camoo.hosting/v1/confirms/antic

Confirm Antic domain

Confirms an Antic domain using the validation hash.

Parameters

Parameter	Type	Required	Description
`hash`	string	required	Validation hash received by email.

curl -X POST 'https://api.camoo.hosting/v1/confirms/antic' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'hash=validation-hash'

const formData = new FormData();
formData.append('hash', 'validation-hash');

const response = await fetch('https://api.camoo.hosting/v1/confirms/antic', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/confirms/antic"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "hash": "validation-hash"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/confirms/antic');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'hash' => 'validation-hash',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("hash", "validation-hash")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/confirms/antic", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "domain": "ok"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

hash *

POST https://api.camoo.hosting/v1/confirms/handle

Confirm handle change

Confirms a registrant handle change using the validation hash.

Parameters

Parameter	Type	Required	Description
`hash`	string	required	Validation hash received by email.

curl -X POST 'https://api.camoo.hosting/v1/confirms/handle' \
  -H 'Authorization: Bearer <access_token>' \
  -F 'hash=validation-hash'

const formData = new FormData();
formData.append('hash', 'validation-hash');

const response = await fetch('https://api.camoo.hosting/v1/confirms/handle', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  },
  body: formData
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/confirms/handle"
headers = {
    "Authorization": "Bearer <access_token>"
}
data = {
    "hash": "validation-hash"
}

response = requests.post(url, headers=headers, data=data)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/confirms/handle');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
    CURLOPT_POSTFIELDS => [
        'hash' => 'validation-hash',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"bytes"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

func main() {
	payload := &bytes.Buffer{}
	writer := multipart.NewWriter(payload)
	_ = writer.WriteField("hash", "validation-hash")
	_ = writer.Close()

	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/confirms/handle", payload)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Content-Type", writer.FormDataContentType())
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "OK",
    "result": {
        "handle_change": "ok"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›

hash *

Error

CAMOO API raises errors for many reasons (authentication, invalid parameters, network / server errors etc.). In case of failed action, we always return the status KO.

curl -X POST 'https://api.camoo.hosting/v1/' \
  -H 'Authorization: Bearer <access_token>'

const response = await fetch('https://api.camoo.hosting/v1/', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <access_token>'
  }
});

const data = await response.json();
console.log(data);

import requests

url = "https://api.camoo.hosting/v1/"
headers = {
    "Authorization": "Bearer <access_token>"
}

response = requests.get(url, headers=headers)
print(response.json())

<?php

$ch = curl_init('https://api.camoo.hosting/v1/');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer <access_token>',
    ],
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("POST", "https://api.camoo.hosting/v1/", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer <access_token>")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

{
    "status": "KO",
    "result": {
        "message": "login failed"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Invalid or missing parameters"
    }
}

{
    "status": "KO",
    "result": {
        "message": "Unauthorized: Invalid or expired token"
    }
}

⚡ Try it out Interactive Test Console ›