MENU navbar-image

Introduction

REST API for WaSaaS -- self-hosted WhatsApp messaging platform. All endpoints require an Authorization: Bearer header unless marked as public.

Introduction

WaSaaS exposes a REST API that lets you send WhatsApp messages, manage devices, run bulk campaigns, build chatbot automation flows, and more.

Base URL: https://your-domain.com/api

Authentication: Every endpoint requires Authorization: Bearer <key>. Generate your key from the customer portal under Account -> API Key.

Rate limits: 100 requests per minute per key (configurable per plan).

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {YOUR_API_KEY}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

Generate your API key from the portal under Account -> API Key.

Auth

Register a new customer account.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/auth/register" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"b\",
    \"email\": \"zbailey@example.net\",
    \"password\": \"-0pBNvYgxw\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/auth/register"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "b",
    "email": "zbailey@example.net",
    "password": "-0pBNvYgxw"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/auth/register'
payload = {
    "name": "b",
    "email": "zbailey@example.net",
    "password": "-0pBNvYgxw"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/auth/register';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'b',
            'email' => 'zbailey@example.net',
            'password' => '-0pBNvYgxw',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "message": "Registration successful.",
    "api_key": "wac_live_...",
    "user": {
        "id": 1,
        "name": "Vinayak",
        "email": "v@example.com",
        "api_key_prefix": "wac_"
    }
}

Example response (422):


{
    "message": "The email has already been taken.",
    "errors": {
        "email": [
            "The email has already been taken."
        ]
    }
}

Request      

POST api/auth/register

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string     

Must not be greater than 255 characters. Example: b

email   string     

Must be a valid email address. Example: zbailey@example.net

password   string     

Must be at least 8 characters. Example: -0pBNvYgxw

Log in and receive an API key.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/auth/login" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"gbailey@example.net\",
    \"password\": \"|]|{+-\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/auth/login"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "gbailey@example.net",
    "password": "|]|{+-"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/auth/login'
payload = {
    "email": "gbailey@example.net",
    "password": "|]|{+-"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/auth/login';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'gbailey@example.net',
            'password' => '|]|{+-',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "message": "Login successful.",
    "api_key_prefix": "wac_",
    "user": {
        "id": 1,
        "name": "Vinayak",
        "email": "v@example.com"
    }
}

Example response (401):


{
    "error": "Invalid credentials."
}

Request      

POST api/auth/login

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

email   string     

Must be a valid email address. Example: gbailey@example.net

password   string     

Example: |]|{+-

Regenerate your API key. The old key is immediately invalidated.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/auth/regenerate-key" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/auth/regenerate-key"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/auth/regenerate-key'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/auth/regenerate-key';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "message": "API key regenerated.",
    "api_key": "wac_live_newkey..."
}

Request      

POST api/auth/regenerate-key

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Get the authenticated user's profile and plan.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/auth/me" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/auth/me"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/auth/me'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/auth/me';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "name": "Vinayak",
    "email": "v@example.com",
    "plan": {
        "id": 2,
        "name": "Pro",
        "max_devices": 10
    }
}

Request      

GET api/auth/me

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Devices

List all devices.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/devices" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/devices"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


[
    {
        "id": 1,
        "label": "My Number",
        "phone_number": "919876543210",
        "is_connected": true,
        "driver": "baileys"
    }
]

Request      

GET api/devices

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Create a new device.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/devices" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"label\": \"b\",
    \"webhook_url\": \"http:\\/\\/bailey.com\\/\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/devices"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "label": "b",
    "webhook_url": "http:\/\/bailey.com\/"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices'
payload = {
    "label": "b",
    "webhook_url": "http:\/\/bailey.com\/"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'label' => 'b',
            'webhook_url' => 'http://bailey.com/',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "label": "My Number",
    "session_ref": "dev_abc123",
    "is_connected": false
}

Example response (403):


{
    "error": "Device limit reached for your plan."
}

Request      

POST api/devices

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

label   string     

Must not be greater than 100 characters. Example: b

webhook_url   string  optional    

Must be a valid URL. Must not be greater than 500 characters. Example: http://bailey.com/

Delete a device. Disconnects the WhatsApp session.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/devices/100" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/devices/100"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (204):

Empty response

Request      

DELETE api/devices/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the device. Example: 100

Get a QR code to link a WhatsApp number.

requires authentication

Scan the returned QR with WhatsApp on your phone under Linked Devices. Poll every 3 seconds until status changes to connected.

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/devices/100/qr" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/devices/100/qr"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100/qr'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100/qr';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "qr": "data:image/png;base64,..."
}

Example response (202):


{
    "message": "QR not ready. Retry in 3 seconds."
}

Request      

GET api/devices/{device_id}/qr

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

device_id   integer     

The ID of the device. Example: 100

Check a device's connection status.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/devices/100/status" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/devices/100/status"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100/status'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100/status';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "status": "CONNECTED",
    "connected": true
}

Request      

GET api/devices/{device_id}/status

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

device_id   integer     

The ID of the device. Example: 100

Trigger a reconnection attempt for a disconnected device.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/devices/100/reconnect" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/devices/100/reconnect"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100/reconnect'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100/reconnect';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (202):


{
    "message": "Reconnect initiated. Retry QR in 3 seconds."
}

Request      

POST api/devices/{device_id}/reconnect

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

device_id   integer     

The ID of the device. Example: 100

Templates

List message templates.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/templates" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/templates"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/templates'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/templates';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


[
    {
        "id": 1,
        "name": "Welcome",
        "message_type": "text",
        "is_active": true
    }
]

Request      

GET api/templates

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Create a message template.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/templates" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Welcome\",
    \"message_type\": \"text\",
    \"body\": {
        \"text\": \"Hello {{name}}!\"
    },
    \"is_active\": true
}"

const url = new URL(
    "https://wp.hypweb.in/api/templates"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Welcome",
    "message_type": "text",
    "body": {
        "text": "Hello {{name}}!"
    },
    "is_active": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/templates'
payload = {
    "name": "Welcome",
    "message_type": "text",
    "body": {
        "text": "Hello {{name}}!"
    },
    "is_active": true
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/templates';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Welcome',
            'message_type' => 'text',
            'body' => [
                'text' => 'Hello {{name}}!',
            ],
            'is_active' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "name": "Welcome",
    "message_type": "text",
    "is_active": true
}

Request      

POST api/templates

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string     

Example: Welcome

message_type   string     

One of: text, media, location, contact. Example: text

body   object     

Message payload.

is_active   boolean  optional    

Example: true

Get a single template.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/templates/48" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/templates/48"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/templates/48'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/templates/48';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "name": "Welcome",
    "message_type": "text",
    "body": {
        "text": "Hello!"
    },
    "is_active": true
}

Request      

GET api/templates/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the template. Example: 48

Update a template.

requires authentication

Example request:
curl --request PUT \
    "https://wp.hypweb.in/api/templates/48" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"b\",
    \"message_type\": \"media\",
    \"is_active\": false
}"

const url = new URL(
    "https://wp.hypweb.in/api/templates/48"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "b",
    "message_type": "media",
    "is_active": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/templates/48'
payload = {
    "name": "b",
    "message_type": "media",
    "is_active": false
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/templates/48';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'b',
            'message_type' => 'media',
            'is_active' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "name": "Updated Name",
    "message_type": "text",
    "is_active": true
}

Request      

PUT api/templates/{id}

PATCH api/templates/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the template. Example: 48

Body Parameters

name   string  optional    

Must not be greater than 150 characters. Example: b

message_type   string  optional    

Example: media

Must be one of:
  • text
  • media
  • location
  • contact
body   object  optional    
is_active   boolean  optional    

Example: false

Delete a template.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/templates/48" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/templates/48"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/templates/48'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/templates/48';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (204):

Empty response

Request      

DELETE api/templates/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the template. Example: 48

Contacts

List contacts.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/contacts" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/contacts"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/contacts'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/contacts';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": 1,
            "name": "Vinayak",
            "phone": "919876543210",
            "email": "v@example.com"
        }
    ]
}

Request      

GET api/contacts

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Create a contact.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/contacts" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Vinayak\",
    \"phone\": \"919876543210\",
    \"email\": \"v@example.com\",
    \"company\": \"v\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/contacts"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Vinayak",
    "phone": "919876543210",
    "email": "v@example.com",
    "company": "v"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/contacts'
payload = {
    "name": "Vinayak",
    "phone": "919876543210",
    "email": "v@example.com",
    "company": "v"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/contacts';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Vinayak',
            'phone' => '919876543210',
            'email' => 'v@example.com',
            'company' => 'v',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "phone": "919876543210",
    "name": "Vinayak"
}

Example response (403):


{
    "error": "Contact limit reached for your plan."
}

Request      

POST api/contacts

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string  optional    

optional Example: Vinayak

phone   string     

Example: 919876543210

email   string  optional    

optional Example: v@example.com

company   string  optional    

Must not be greater than 150 characters. Example: v

meta   object  optional    

Get a single contact.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/contacts/14" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/contacts/14"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/contacts/14'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/contacts/14';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "phone": "919876543210",
    "name": "Vinayak",
    "email": "v@example.com"
}

Request      

GET api/contacts/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the contact. Example: 14

Update a contact.

requires authentication

Example request:
curl --request PUT \
    "https://wp.hypweb.in/api/contacts/14" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"b\",
    \"phone\": \"n\",
    \"email\": \"ashly64@example.com\",
    \"company\": \"v\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/contacts/14"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "b",
    "phone": "n",
    "email": "ashly64@example.com",
    "company": "v"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/contacts/14'
payload = {
    "name": "b",
    "phone": "n",
    "email": "ashly64@example.com",
    "company": "v"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/contacts/14';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'b',
            'phone' => 'n',
            'email' => 'ashly64@example.com',
            'company' => 'v',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "phone": "919876543210",
    "name": "Updated Name"
}

Request      

PUT api/contacts/{id}

PATCH api/contacts/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the contact. Example: 14

Body Parameters

name   string  optional    

Must not be greater than 150 characters. Example: b

phone   string  optional    

Must not be greater than 30 characters. Example: n

email   string  optional    

Must be a valid email address. Must not be greater than 150 characters. Example: ashly64@example.com

company   string  optional    

Must not be greater than 150 characters. Example: v

meta   object  optional    

Delete a contact.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/contacts/14" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/contacts/14"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/contacts/14'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/contacts/14';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (204):

Empty response

Request      

DELETE api/contacts/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the contact. Example: 14

Bulk import contacts from a JSON array.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/contacts/import" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"contacts\": [
        {
            \"phone\": \"919876543210\",
            \"name\": \"Vinayak\",
            \"email\": \"ashly64@example.com\"
        }
    ]
}"

const url = new URL(
    "https://wp.hypweb.in/api/contacts/import"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "contacts": [
        {
            "phone": "919876543210",
            "name": "Vinayak",
            "email": "ashly64@example.com"
        }
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/contacts/import'
payload = {
    "contacts": [
        {
            "phone": "919876543210",
            "name": "Vinayak",
            "email": "ashly64@example.com"
        }
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/contacts/import';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'contacts' => [
                [
                    'phone' => '919876543210',
                    'name' => 'Vinayak',
                    'email' => 'ashly64@example.com',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "message": "Import complete. Created: 47, Skipped (duplicate): 3.",
    "created": 47,
    "skipped": 3
}

Example response (403):


{
    "error": "Contact limit reached for your plan."
}

Request      

POST api/contacts/import

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

contacts   object[]     

Array of contact objects.
phone   string     

Example: 919876543210

name   string  optional    

optional Example: Vinayak

email   string  optional    

Must be a valid email address. Must not be greater than 150 characters. Example: ashly64@example.com

Groups

List contact groups.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/groups" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/groups"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/groups'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/groups';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


[
    {
        "id": 1,
        "name": "VIP Customers",
        "contacts_count": 120
    }
]

Request      

GET api/groups

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Create a contact group.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/groups" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"VIP Customers\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/groups"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "VIP Customers"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/groups'
payload = {
    "name": "VIP Customers"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/groups';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'VIP Customers',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "name": "VIP Customers",
    "contacts_count": 0
}

Request      

POST api/groups

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

name   string     

Example: VIP Customers

Get a group with its contacts.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/groups/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/groups/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/groups/16'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/groups/16';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "name": "VIP Customers",
    "contacts": [
        {
            "id": 1,
            "phone": "919876543210",
            "name": "Vinayak"
        }
    ]
}

Request      

GET api/groups/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the group. Example: 16

Update a group name.

requires authentication

Example request:
curl --request PUT \
    "https://wp.hypweb.in/api/groups/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Premium Members\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/groups/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "Premium Members"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/groups/16'
payload = {
    "name": "Premium Members"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/groups/16';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Premium Members',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "name": "Premium Members"
}

Request      

PUT api/groups/{id}

PATCH api/groups/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the group. Example: 16

Body Parameters

name   string     

Example: Premium Members

Delete a group.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/groups/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/groups/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/groups/16'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/groups/16';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (204):

Empty response

Request      

DELETE api/groups/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the group. Example: 16

Add contacts to a group.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/groups/16/contacts" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"contact_ids\": [
        1,
        2,
        3
    ]
}"

const url = new URL(
    "https://wp.hypweb.in/api/groups/16/contacts"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "contact_ids": [
        1,
        2,
        3
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/groups/16/contacts'
payload = {
    "contact_ids": [
        1,
        2,
        3
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/groups/16/contacts';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'contact_ids' => [
                1,
                2,
                3,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "message": "Contacts added.",
    "count": 3
}

Request      

POST api/groups/{group_id}/contacts

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

group_id   integer     

The ID of the group. Example: 16

Body Parameters

contact_ids   integer[]     

Array of contact IDs to add.

Remove a contact from a group.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/groups/16/contacts/14" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/groups/16/contacts/14"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/groups/16/contacts/14'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/groups/16/contacts/14';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (204):

Empty response

Request      

DELETE api/groups/{group_id}/contacts/{contact_id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

group_id   integer     

The ID of the group. Example: 16

contact_id   integer     

The ID of the contact. Example: 14

Messages

Send a single WhatsApp message immediately.

requires authentication

Supports text, media, location, contact card, button, and menu types. The device must be connected.

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/messages/send" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"device_id\": 16,
    \"template_id\": 16,
    \"phone\": \"n\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/messages/send"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "device_id": 16,
    "template_id": 16,
    "phone": "n"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/messages/send'
payload = {
    "device_id": 16,
    "template_id": 16,
    "phone": "n"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/messages/send';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'device_id' => 16,
            'template_id' => 16,
            'phone' => 'n',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "success": true,
    "message_log_id": 42
}

Example response (403):


{
    "error": "Daily message limit reached for your plan."
}

Example response (422):


{
    "error": "Device is not connected."
}

Request      

POST api/messages/send

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

device_id   integer     

Example: 16

template_id   integer     

Example: 16

phone   string     

Must not be greater than 30 characters. Example: n

variables   object  optional    

List outbound and inbound message logs.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/messages?direction=outbound&status=sent" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/messages"
);

const params = {
    "direction": "outbound",
    "status": "sent",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/messages'
params = {
  'direction': 'outbound',
  'status': 'sent',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/messages';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'direction' => 'outbound',
            'status' => 'sent',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": 1,
            "phone_number": "919876543210",
            "message_type": "text",
            "status": "sent",
            "sent_at": "2026-06-30T10:00:00Z"
        }
    ],
    "total": 42
}

Request      

GET api/messages

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Query Parameters

direction   string  optional    

Filter by direction: outbound or inbound. Example: outbound

status   string  optional    

Filter by status: sent, failed, received. Example: sent

Campaigns

List campaigns.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/campaigns" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/campaigns"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/campaigns'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/campaigns';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": 1,
            "title": "June Blast",
            "status": "completed",
            "total_count": 500,
            "sent_count": 498,
            "failed_count": 2
        }
    ]
}

Request      

GET api/campaigns

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Create a campaign.

requires authentication

Provide either group_id or a phones array (or both).

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/campaigns" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"June Blast\",
    \"device_id\": 1,
    \"template_id\": 3,
    \"delay_seconds\": 10,
    \"scheduled_at\": \"2026-07-01T09:00:00Z\",
    \"group_id\": 2,
    \"phones\": [
        \"919876543210\"
    ]
}"

const url = new URL(
    "https://wp.hypweb.in/api/campaigns"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "June Blast",
    "device_id": 1,
    "template_id": 3,
    "delay_seconds": 10,
    "scheduled_at": "2026-07-01T09:00:00Z",
    "group_id": 2,
    "phones": [
        "919876543210"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/campaigns'
payload = {
    "title": "June Blast",
    "device_id": 1,
    "template_id": 3,
    "delay_seconds": 10,
    "scheduled_at": "2026-07-01T09:00:00Z",
    "group_id": 2,
    "phones": [
        "919876543210"
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/campaigns';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'June Blast',
            'device_id' => 1,
            'template_id' => 3,
            'delay_seconds' => 10,
            'scheduled_at' => '2026-07-01T09:00:00Z',
            'group_id' => 2,
            'phones' => [
                '919876543210',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "title": "June Blast",
    "status": "draft",
    "total_count": 500
}

Example response (403):


{
    "error": "Campaign limit reached for your plan."
}

Request      

POST api/campaigns

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

title   string     

Campaign name. Example: June Blast

device_id   integer     

Connected device ID. Example: 1

template_id   integer     

Template ID. Example: 3

delay_seconds   integer  optional    

Seconds between sends. Default: 5. Example: 10

scheduled_at   string  optional    

ISO 8601 datetime to start. Example: 2026-07-01T09:00:00Z

group_id   integer  optional    

optional Contact group ID. Example: 2

phones   string[]  optional    

optional Array of phone numbers.

Get a campaign with its template, device, and recipient summary.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/campaigns/29" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/campaigns/29"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/campaigns/29'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/campaigns/29';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "title": "June Blast",
    "status": "completed",
    "sent_count": 498,
    "failed_count": 2,
    "template": {
        "name": "Welcome"
    },
    "device": {
        "label": "My Number"
    }
}

Request      

GET api/campaigns/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the campaign. Example: 29

Launch a draft campaign. Transitions status from draft to queued.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/campaigns/29/launch" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/campaigns/29/launch"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/campaigns/29/launch'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/campaigns/29/launch';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "message": "Campaign queued.",
    "campaign": {
        "status": "queued"
    }
}

Example response (422):


{
    "error": "Cannot launch a campaign with status 'completed'."
}

Request      

POST api/campaigns/{campaign_id}/launch

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

campaign_id   integer     

The ID of the campaign. Example: 29

Cancel a draft or queued campaign.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/campaigns/29/cancel" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/campaigns/29/cancel"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/campaigns/29/cancel'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/campaigns/29/cancel';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "status": "cancelled"
}

Example response (422):


{
    "error": "Cannot cancel a campaign with status 'completed'."
}

Request      

POST api/campaigns/{campaign_id}/cancel

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

campaign_id   integer     

The ID of the campaign. Example: 29

List recipients for a campaign with their delivery status.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/campaigns/29/recipients?status=failed" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/campaigns/29/recipients"
);

const params = {
    "status": "failed",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/campaigns/29/recipients'
params = {
  'status': 'failed',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/campaigns/29/recipients';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'status' => 'failed',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "phone": "919876543210",
            "status": "sent",
            "sent_at": "2026-06-30T10:00:00Z"
        }
    ]
}

Request      

GET api/campaigns/{campaign_id}/recipients

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

campaign_id   integer     

The ID of the campaign. Example: 29

Query Parameters

status   string  optional    

Filter by status: pending, sent, failed. Example: failed

Scheduled Messages

List scheduled messages.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/scheduled-messages" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/scheduled-messages"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/scheduled-messages'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/scheduled-messages';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": 1,
            "phone": "919876543210",
            "message_type": "text",
            "status": "pending",
            "scheduled_for": "2026-07-01T09:00:00Z"
        }
    ]
}

Request      

GET api/scheduled-messages

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Schedule a single message for future delivery.

requires authentication

Provide either template_id or message_type + payload for an inline message.

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/scheduled-messages" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"device_id\": 1,
    \"phone\": \"919876543210\",
    \"template_id\": 3,
    \"message_type\": \"text\",
    \"payload\": {
        \"text\": \"Hello!\"
    },
    \"variables\": {
        \"name\": \"Vinayak\"
    },
    \"scheduled_for\": \"2026-07-01T09:00:00Z\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/scheduled-messages"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "device_id": 1,
    "phone": "919876543210",
    "template_id": 3,
    "message_type": "text",
    "payload": {
        "text": "Hello!"
    },
    "variables": {
        "name": "Vinayak"
    },
    "scheduled_for": "2026-07-01T09:00:00Z"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/scheduled-messages'
payload = {
    "device_id": 1,
    "phone": "919876543210",
    "template_id": 3,
    "message_type": "text",
    "payload": {
        "text": "Hello!"
    },
    "variables": {
        "name": "Vinayak"
    },
    "scheduled_for": "2026-07-01T09:00:00Z"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/scheduled-messages';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'device_id' => 1,
            'phone' => '919876543210',
            'template_id' => 3,
            'message_type' => 'text',
            'payload' => [
                'text' => 'Hello!',
            ],
            'variables' => [
                'name' => 'Vinayak',
            ],
            'scheduled_for' => '2026-07-01T09:00:00Z',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "status": "pending",
    "scheduled_for": "2026-07-01T09:00:00Z"
}

Request      

POST api/scheduled-messages

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

device_id   integer     

Example: 1

phone   string     

E.164 without +. Example: 919876543210

template_id   integer  optional    

optional Saved template ID. Example: 3

message_type   string     

if no template_id. Example: text

payload   object     

if no template_id.

variables   object  optional    

optional Template variable values.

scheduled_for   string     

ISO 8601 datetime in the future. Example: 2026-07-01T09:00:00Z

Cancel a pending scheduled message.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/scheduled-messages/architecto" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/scheduled-messages/architecto"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/scheduled-messages/architecto'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/scheduled-messages/architecto';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "success": true
}

Example response (422):


{
    "error": "Only pending messages can be cancelled."
}

Request      

DELETE api/scheduled-messages/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   string     

The ID of the scheduled message. Example: architecto

Chatbot Rules

List chatbot rules across all devices.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/chatbot-rules" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/chatbot-rules"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/chatbot-rules'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/chatbot-rules';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


[
    {
        "id": 1,
        "keyword": "hello",
        "match_type": "contains",
        "reply_type": "text",
        "is_active": true
    }
]

Request      

GET api/chatbot-rules

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Create a chatbot rule.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/chatbot-rules" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"device_id\": 1,
    \"keyword\": \"hello\",
    \"match_type\": \"contains\",
    \"reply_type\": \"text\",
    \"reply_body\": {
        \"text\": \"Hi there!\"
    },
    \"is_active\": true
}"

const url = new URL(
    "https://wp.hypweb.in/api/chatbot-rules"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "device_id": 1,
    "keyword": "hello",
    "match_type": "contains",
    "reply_type": "text",
    "reply_body": {
        "text": "Hi there!"
    },
    "is_active": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/chatbot-rules'
payload = {
    "device_id": 1,
    "keyword": "hello",
    "match_type": "contains",
    "reply_type": "text",
    "reply_body": {
        "text": "Hi there!"
    },
    "is_active": true
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/chatbot-rules';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'device_id' => 1,
            'keyword' => 'hello',
            'match_type' => 'contains',
            'reply_type' => 'text',
            'reply_body' => [
                'text' => 'Hi there!',
            ],
            'is_active' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "keyword": "hello",
    "match_type": "contains",
    "reply_type": "text",
    "is_active": true
}

Request      

POST api/chatbot-rules

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

device_id   integer     

Example: 1

keyword   string     

Example: hello

match_type   string     

One of: exact, contains, starts_with. Example: contains

reply_type   string     

One of: text, media. Example: text

reply_body   object     

Reply payload matching the reply_type.

is_active   boolean  optional    

Example: true

Get a single chatbot rule.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/chatbot-rules/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/chatbot-rules/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/chatbot-rules/16'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/chatbot-rules/16';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "keyword": "hello",
    "match_type": "contains",
    "reply_type": "text",
    "reply_body": {
        "text": "Hi!"
    }
}

Request      

GET api/chatbot-rules/{rule_id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

rule_id   integer     

The ID of the rule. Example: 16

Update a chatbot rule.

requires authentication

Example request:
curl --request PUT \
    "https://wp.hypweb.in/api/chatbot-rules/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"keyword\": \"b\",
    \"match_type\": \"exact\",
    \"reply_type\": \"text\",
    \"is_active\": false
}"

const url = new URL(
    "https://wp.hypweb.in/api/chatbot-rules/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "keyword": "b",
    "match_type": "exact",
    "reply_type": "text",
    "is_active": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/chatbot-rules/16'
payload = {
    "keyword": "b",
    "match_type": "exact",
    "reply_type": "text",
    "is_active": false
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/chatbot-rules/16';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'keyword' => 'b',
            'match_type' => 'exact',
            'reply_type' => 'text',
            'is_active' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "keyword": "hi",
    "match_type": "exact",
    "reply_type": "text",
    "is_active": false
}

Request      

PUT api/chatbot-rules/{rule_id}

PATCH api/chatbot-rules/{rule_id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

rule_id   integer     

The ID of the rule. Example: 16

Body Parameters

keyword   string  optional    

Must not be greater than 200 characters. Example: b

match_type   string  optional    

Example: exact

Must be one of:
  • exact
  • contains
  • starts_with
reply_type   string  optional    

Example: text

Must be one of:
  • text
  • media
reply_body   object  optional    
is_active   boolean  optional    

Example: false

Delete a chatbot rule.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/chatbot-rules/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/chatbot-rules/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/chatbot-rules/16'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/chatbot-rules/16';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (204):

Empty response

Request      

DELETE api/chatbot-rules/{rule_id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

rule_id   integer     

The ID of the rule. Example: 16

Flows

Get execution logs for a flow.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/flows/architecto/logs" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/flows/architecto/logs"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/flows/architecto/logs'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/flows/architecto/logs';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "contact_phone": "919876543210",
            "status": "completed",
            "triggered_at": "2026-06-30T10:00:00Z"
        }
    ]
}

Request      

GET api/flows/{id}/logs

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   string     

The ID of the flow. Example: architecto

Toggle a flow active/inactive.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/flows/architecto/toggle" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/flows/architecto/toggle"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/flows/architecto/toggle'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/flows/architecto/toggle';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "is_active": false
}

Request      

POST api/flows/{id}/toggle

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   string     

The ID of the flow. Example: architecto

List automation flows.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/flows" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/flows"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/flows'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/flows';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


[
    {
        "id": 1,
        "name": "Welcome flow",
        "trigger_type": "keyword",
        "is_active": true
    }
]

Request      

GET api/flows

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Create a flow.

requires authentication

Nodes and edges follow the React Flow JSON schema.

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/flows" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"device_id\": 1,
    \"name\": \"Welcome flow\",
    \"trigger_type\": \"keyword\",
    \"trigger_config\": {
        \"keyword\": \"hello\",
        \"match_type\": \"contains\"
    },
    \"nodes\": [
        []
    ],
    \"edges\": [
        []
    ]
}"

const url = new URL(
    "https://wp.hypweb.in/api/flows"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "device_id": 1,
    "name": "Welcome flow",
    "trigger_type": "keyword",
    "trigger_config": {
        "keyword": "hello",
        "match_type": "contains"
    },
    "nodes": [
        []
    ],
    "edges": [
        []
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/flows'
payload = {
    "device_id": 1,
    "name": "Welcome flow",
    "trigger_type": "keyword",
    "trigger_config": {
        "keyword": "hello",
        "match_type": "contains"
    },
    "nodes": [
        []
    ],
    "edges": [
        []
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/flows';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'device_id' => 1,
            'name' => 'Welcome flow',
            'trigger_type' => 'keyword',
            'trigger_config' => [
                'keyword' => 'hello',
                'match_type' => 'contains',
            ],
            'nodes' => [
                [],
            ],
            'edges' => [
                [],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "name": "Welcome flow",
    "trigger_type": "keyword",
    "is_active": true
}

Request      

POST api/flows

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

device_id   integer     

Example: 1

name   string     

Example: Welcome flow

trigger_type   string     

One of: any_message, keyword, button_reply. Example: keyword

trigger_config   object  optional    

optional

nodes   object[]     

Array of React Flow node objects.

edges   object[]     

Array of React Flow edge objects.

Blacklist

List blacklisted numbers.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/blacklist" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/blacklist"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/blacklist'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/blacklist';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": 1,
            "phone": "919876543210",
            "reason": "Replied STOP",
            "source": "opt_out"
        }
    ]
}

Request      

GET api/blacklist

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Add a number to the blacklist.

requires authentication

Numbers on the blacklist are skipped in all campaign sends.

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/blacklist" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"phone\": \"919876543210\",
    \"reason\": \"Customer requested removal\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/blacklist"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "phone": "919876543210",
    "reason": "Customer requested removal"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/blacklist'
payload = {
    "phone": "919876543210",
    "reason": "Customer requested removal"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/blacklist';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'phone' => '919876543210',
            'reason' => 'Customer requested removal',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "phone": "919876543210",
    "source": "manual"
}

Request      

POST api/blacklist

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

phone   string     

Example: 919876543210

reason   string  optional    

optional Example: Customer requested removal

Remove a number from the blacklist.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/blacklist/architecto" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/blacklist/architecto"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/blacklist/architecto'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/blacklist/architecto';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "success": true
}

Request      

DELETE api/blacklist/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   string     

The ID of the blacklist. Example: architecto

Inbound Events

List inbound events received by your devices.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/inbound-events?device_id=1&event_type=message_received" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/inbound-events"
);

const params = {
    "device_id": "1",
    "event_type": "message_received",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/inbound-events'
params = {
  'device_id': '1',
  'event_type': 'message_received',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/inbound-events';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'device_id' => '1',
            'event_type' => 'message_received',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": 1,
            "event_type": "message_received",
            "from": "919876543210",
            "payload": {
                "text": "Hello"
            },
            "created_at": "2026-06-30T10:00:00Z"
        }
    ]
}

Request      

GET api/inbound-events

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Query Parameters

device_id   integer  optional    

Filter by device. Example: 1

event_type   string  optional    

Filter by type, e.g. message_received. Example: message_received

Support

List support tickets.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/support/tickets" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/support/tickets"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/support/tickets'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/support/tickets';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": 1,
            "ticket_no": "TKT-ABCD1234",
            "subject": "Need help",
            "status": "open",
            "priority": "medium"
        }
    ]
}

Request      

GET api/support/tickets

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Open a new support ticket.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/support/tickets" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject\": \"Cannot connect device\",
    \"priority\": \"high\",
    \"body\": \"My device shows disconnected.\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/support/tickets"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "Cannot connect device",
    "priority": "high",
    "body": "My device shows disconnected."
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/support/tickets'
payload = {
    "subject": "Cannot connect device",
    "priority": "high",
    "body": "My device shows disconnected."
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/support/tickets';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject' => 'Cannot connect device',
            'priority' => 'high',
            'body' => 'My device shows disconnected.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "ticket_no": "TKT-ABCD1234",
    "subject": "Cannot connect device",
    "status": "open"
}

Request      

POST api/support/tickets

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

subject   string     

Example: Cannot connect device

priority   string  optional    

optional One of: low, medium, high. Default: medium. Example: high

body   string     

Initial message body. Example: My device shows disconnected.

Get a ticket with its message thread.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/support/tickets/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/support/tickets/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/support/tickets/16'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/support/tickets/16';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "ticket_no": "TKT-ABCD1234",
    "subject": "Cannot connect device",
    "messages": [
        {
            "body": "My device shows disconnected.",
            "is_staff": false
        }
    ]
}

Request      

GET api/support/tickets/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the ticket. Example: 16

Update a ticket's status.

requires authentication

Example request:
curl --request PUT \
    "https://wp.hypweb.in/api/support/tickets/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"status\": \"closed\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/support/tickets/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "status": "closed"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/support/tickets/16'
payload = {
    "status": "closed"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/support/tickets/16';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'status' => 'closed',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "id": 1,
    "status": "closed"
}

Request      

PUT api/support/tickets/{id}

PATCH api/support/tickets/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the ticket. Example: 16

Body Parameters

status   string     

One of: open, pending, closed. Example: closed

Close and delete a support ticket.

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/support/tickets/16" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/support/tickets/16"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/support/tickets/16'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/support/tickets/16';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (204):

Empty response

Request      

DELETE api/support/tickets/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the ticket. Example: 16

Billing

List available plans.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/plans" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/plans"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/plans'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/plans';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


[
    {
        "id": 1,
        "name": "Starter",
        "price": "9.00",
        "max_devices": 3,
        "max_contacts": 1000
    }
]

Request      

GET api/plans

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Create a billing order for a plan upgrade.

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/billing/orders" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"plan_id\": 2,
    \"gateway_id\": 1
}"

const url = new URL(
    "https://wp.hypweb.in/api/billing/orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "plan_id": 2,
    "gateway_id": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/billing/orders'
payload = {
    "plan_id": 2,
    "gateway_id": 1
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/billing/orders';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'plan_id' => 2,
            'gateway_id' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (201):


{
    "id": 1,
    "invoice_no": "INV-XXXXXXXXXX",
    "amount": "9.00",
    "status": "pending"
}

Request      

POST api/billing/orders

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

plan_id   integer     

Example: 2

gateway_id   integer     

Example: 1

List billing orders.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/billing/orders" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/billing/orders"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/billing/orders'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/billing/orders';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "data": [
        {
            "id": 1,
            "invoice_no": "INV-XXXXXXXXXX",
            "amount": "9.00",
            "status": "completed",
            "created_at": "2026-06-30"
        }
    ]
}

Request      

GET api/billing/orders

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Get current plan quota usage.

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/billing/quota" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/billing/quota"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/billing/quota'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/billing/quota';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (200):


{
    "devices": {
        "used": 2,
        "max": 10
    },
    "contacts": {
        "used": 450,
        "max": 10000
    },
    "messages_today": {
        "used": 120,
        "max": 10000
    },
    "active_campaigns": {
        "used": 1,
        "max": 50
    }
}

Request      

GET api/billing/quota

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Endpoints

GET api/flows/{id}

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/flows/architecto" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/flows/architecto"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/flows/architecto'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/flows/architecto';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "error": "Invalid API key."
}

Request      

GET api/flows/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   string     

The ID of the flow. Example: architecto

PUT api/flows/{id}

requires authentication

Example request:
curl --request PUT \
    "https://wp.hypweb.in/api/flows/architecto" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/flows/architecto"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/flows/architecto'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/flows/architecto';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

PUT api/flows/{id}

PATCH api/flows/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   string     

The ID of the flow. Example: architecto

DELETE api/flows/{id}

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/flows/architecto" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/flows/architecto"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/flows/architecto'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/flows/architecto';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

DELETE api/flows/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   string     

The ID of the flow. Example: architecto

GET api/devices/{id}

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/devices/100" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/devices/100"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "error": "Invalid API key."
}

Request      

GET api/devices/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the device. Example: 100

PUT api/devices/{id}

requires authentication

Example request:
curl --request PUT \
    "https://wp.hypweb.in/api/devices/100" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"label\": \"b\",
    \"webhook_url\": \"http:\\/\\/bailey.com\\/\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/devices/100"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "label": "b",
    "webhook_url": "http:\/\/bailey.com\/"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100'
payload = {
    "label": "b",
    "webhook_url": "http:\/\/bailey.com\/"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'label' => 'b',
            'webhook_url' => 'http://bailey.com/',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

PUT api/devices/{id}

PATCH api/devices/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the device. Example: 100

Body Parameters

label   string  optional    

Must not be greater than 100 characters. Example: b

webhook_url   string  optional    

Must be a valid URL. Must not be greater than 500 characters. Example: http://bailey.com/

PUT api/campaigns/{id}

requires authentication

Example request:
curl --request PUT \
    "https://wp.hypweb.in/api/campaigns/29" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"title\": \"b\",
    \"delay_seconds\": 22,
    \"scheduled_at\": \"2052-07-23\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/campaigns/29"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "title": "b",
    "delay_seconds": 22,
    "scheduled_at": "2052-07-23"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/campaigns/29'
payload = {
    "title": "b",
    "delay_seconds": 22,
    "scheduled_at": "2052-07-23"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/campaigns/29';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'title' => 'b',
            'delay_seconds' => 22,
            'scheduled_at' => '2052-07-23',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

PUT api/campaigns/{id}

PATCH api/campaigns/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the campaign. Example: 29

Body Parameters

title   string  optional    

Must not be greater than 200 characters. Example: b

delay_seconds   integer  optional    

Must be at least 0. Must not be greater than 60. Example: 22

scheduled_at   string  optional    

Must be a valid date. Must be a date after now. Example: 2052-07-23

DELETE api/campaigns/{id}

requires authentication

Example request:
curl --request DELETE \
    "https://wp.hypweb.in/api/campaigns/29" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/campaigns/29"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/campaigns/29'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/campaigns/29';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

DELETE api/campaigns/{id}

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

id   integer     

The ID of the campaign. Example: 29

GET api/support/tickets/{ticketId}/messages

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/support/tickets/architecto/messages" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/support/tickets/architecto/messages"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/support/tickets/architecto/messages'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/support/tickets/architecto/messages';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "error": "Invalid API key."
}

Request      

GET api/support/tickets/{ticketId}/messages

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

ticketId   string     

Example: architecto

POST api/support/tickets/{ticketId}/messages

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/support/tickets/architecto/messages" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"body\": \"b\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/support/tickets/architecto/messages"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "body": "b"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/support/tickets/architecto/messages'
payload = {
    "body": "b"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/support/tickets/architecto/messages';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'body' => 'b',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

POST api/support/tickets/{ticketId}/messages

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

ticketId   string     

Example: architecto

Body Parameters

body   string     

Must not be greater than 5000 characters. Example: b

GET api/devices/{deviceId}/groups

requires authentication

Example request:
curl --request GET \
    --get "https://wp.hypweb.in/api/devices/100/groups" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://wp.hypweb.in/api/devices/100/groups"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100/groups'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100/groups';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "error": "Invalid API key."
}

Request      

GET api/devices/{deviceId}/groups

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

deviceId   integer     

Example: 100

POST api/devices/{deviceId}/groups/{groupId}/send-text

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/devices/100/groups/16/send-text" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"body\": \"architecto\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/devices/100/groups/16/send-text"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "body": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100/groups/16/send-text'
payload = {
    "body": "architecto"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100/groups/16/send-text';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'body' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

POST api/devices/{deviceId}/groups/{groupId}/send-text

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

deviceId   integer     

Example: 100

groupId   integer     

Example: 16

Body Parameters

body   string     

Example: architecto

POST api/devices/{deviceId}/groups/{groupId}/send-media

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/devices/100/groups/16/send-media" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"media_url\": \"http:\\/\\/www.bailey.biz\\/quos-velit-et-fugiat-sunt-nihil-accusantium-harum.html\",
    \"type\": \"video\",
    \"caption\": \"architecto\"
}"

const url = new URL(
    "https://wp.hypweb.in/api/devices/100/groups/16/send-media"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "media_url": "http:\/\/www.bailey.biz\/quos-velit-et-fugiat-sunt-nihil-accusantium-harum.html",
    "type": "video",
    "caption": "architecto"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/devices/100/groups/16/send-media'
payload = {
    "media_url": "http:\/\/www.bailey.biz\/quos-velit-et-fugiat-sunt-nihil-accusantium-harum.html",
    "type": "video",
    "caption": "architecto"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/devices/100/groups/16/send-media';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'media_url' => 'http://www.bailey.biz/quos-velit-et-fugiat-sunt-nihil-accusantium-harum.html',
            'type' => 'video',
            'caption' => 'architecto',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

POST api/devices/{deviceId}/groups/{groupId}/send-media

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

URL Parameters

deviceId   integer     

Example: 100

groupId   integer     

Example: 16

Body Parameters

media_url   string     

Must be a valid URL. Example: http://www.bailey.biz/quos-velit-et-fugiat-sunt-nihil-accusantium-harum.html

type   string  optional    

Example: video

Must be one of:
  • image
  • video
  • document
caption   string  optional    

Example: architecto

POST api/billing/checkout

requires authentication

Example request:
curl --request POST \
    "https://wp.hypweb.in/api/billing/checkout" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"plan_id\": 16,
    \"gateway_id\": 16
}"

const url = new URL(
    "https://wp.hypweb.in/api/billing/checkout"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "plan_id": 16,
    "gateway_id": 16
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
import requests
import json

url = 'https://wp.hypweb.in/api/billing/checkout'
payload = {
    "plan_id": 16,
    "gateway_id": 16
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()
$client = new \GuzzleHttp\Client();
$url = 'https://wp.hypweb.in/api/billing/checkout';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'plan_id' => 16,
            'gateway_id' => 16,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

Request      

POST api/billing/checkout

Headers

Authorization        

Example: Bearer {YOUR_API_KEY}

Content-Type        

Example: application/json

Accept        

Example: application/json

Body Parameters

plan_id   integer     

Must match an existing stored value. Example: 16

gateway_id   integer     

Must match an existing stored value. Example: 16