Developer guide

From access token to your first SMS

Get started with the REST API, OAuth 2.0 and open developer documentation. API access is included with every Intellipush account.

Create a free account Open API documentation

No monthly platform fee
No lock-in
SMS credits valid for 24 months

1. Authenticate

Create the required access and obtain an OAuth 2.0 token from the documentation.

2. Build the request

Follow the documentation for recipient, sender and message content.

3. Handle the response

Retain relevant technical references and handle failures explicitly.

Practical overview

Build the first integration deliberately

Start with the current API documentation. It contains the authoritative descriptions of access, fields and technical responses. This guide explains the implementation sequence around that contract; it does not replace the documentation.

Decide which event should send the message and what your system needs to know afterwards. Separate configuration and secrets from application code. Normalise telephone numbers before building the request, and understand the message length before estimating usage.

Plan operations before the first production call. A responsible owner should be able to stop the flow, recognise the technical signals that indicate failure and locate a request without retrieving more personal data than necessary. Record these decisions alongside the integration.

Workflow

From development to a production-ready flow

Make each stage observable without turning message content or personal data into default log output.

01
Create access
Follow the documentation for account and API access. Decide which environments and people genuinely need the credentials.
02
Obtain and handle the token
Use OAuth 2.0 as documented. Store tokens and client secrets securely, rotate them when required and never commit them to a public repository.
03
Construct the request
Validate recipient, sender and text before the call. Use documented fields, and include a safeguard against unintended bulk delivery.
04
Interpret technical responses
Handle both accepted requests and errors. Retain correlation or reference values required for diagnosis without copying the entire message into logs.
05
Test representative cases
Test valid and invalid numbers, character sets, long messages, service unavailability and retries. Begin with your own recipients and a low volume.
06
Prepare operations
Limit access and volume, monitor failures in a privacy-conscious way and document who responds when the integration stops.

Runnable quickstart

Obtain a token and create one SMS

These examples follow the current OpenAPI contract. Replace only the environment variables and use a test number you control.

01
Store credentials as secrets
Use the API ID and API Secret issued for the account. Store them in secure environment variables — never in public client-side code or a public repository.
shell
```
export INTELLIPUSH_API_ID="your_api_id"
export INTELLIPUSH_API_SECRET="your_api_secret"
```

Obtain an OAuth 2.0 token

The token endpoint uses HTTP Basic with the API ID as the username and API Secret as the password. The response contains a time-limited access token.

cURL

curl --request POST \
  --url https://api.intellipush.com/oauth2/token \
  --user "$INTELLIPUSH_API_ID:$INTELLIPUSH_API_SECRET" \
  --header "Content-Type: application/json" \
  --data '{"grant_type":"client_credentials"}'

Example token response

{
  "access_token": "eyJ...",
  "expires_in": 3600,
  "token_type": "Bearer",
  "scope": ""
}

Create one SMS

Put the access token in the environment variable below. This call creates a real SMS and may use SMS credits, so begin with your own number and a low volume.

cURL

export INTELLIPUSH_ACCESS_TOKEN="your_access_token"

curl --request POST \
  --url https://api.intellipush.com/restv2/sms/create \
  --header "Authorization: Bearer $INTELLIPUSH_ACCESS_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "message": "Your appointment is confirmed.",
    "countrycode": "+47",
    "phonenumber": "12345678"
  }'

Example accepted response

{
  "success": true,
  "data": {
    "id": 1210966,
    "message": "Your appointment is confirmed.",
    "countrycode": "+47",
    "phonenumber": "+4712345678",
    "sent": 0,
    "failed": 0,
    "deleted": 0
  },
  "status_message": "SMS was created successfully."
}

Distinguish creation from delivery

An accepted creation response means the message has been registered. Use the returned ID with the status endpoint when the workflow needs delivery information.

cURL

curl --request POST \
  --url https://api.intellipush.com/restv2/sms/status \
  --header "Authorization: Bearer $INTELLIPUSH_ACCESS_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{"id_array":[1210966]}'

More languages

The same contract in Node.js and Python

The examples use environment variables and send one real SMS.

Node.js 18+

const apiId = process.env.INTELLIPUSH_API_ID;
const apiSecret = process.env.INTELLIPUSH_API_SECRET;
const basic = Buffer.from(`${apiId}:${apiSecret}`).toString('base64');

const tokenResponse = await fetch('https://api.intellipush.com/oauth2/token', {
  method: 'POST',
  headers: {
    Authorization: `Basic ${basic}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ grant_type: 'client_credentials' })
});
if (!tokenResponse.ok) throw new Error(`Token request failed (${tokenResponse.status})`);
const { access_token } = await tokenResponse.json();

const smsResponse = await fetch('https://api.intellipush.com/restv2/sms/create', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${access_token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    message: 'Your appointment is confirmed.',
    countrycode: '+47',
    phonenumber: '12345678'
  })
});
if (!smsResponse.ok) throw new Error(`SMS request failed (${smsResponse.status})`);
console.log(await smsResponse.json());

Python 3

import base64
import json
import os
from urllib.request import Request, urlopen

api_id = os.environ['INTELLIPUSH_API_ID']
api_secret = os.environ['INTELLIPUSH_API_SECRET']
basic = base64.b64encode(f'{api_id}:{api_secret}'.encode()).decode()

token_request = Request(
    'https://api.intellipush.com/oauth2/token',
    data=json.dumps({'grant_type': 'client_credentials'}).encode(),
    headers={'Authorization': f'Basic {basic}', 'Content-Type': 'application/json'},
    method='POST'
)
with urlopen(token_request) as response:
    access_token = json.load(response)['access_token']

sms_request = Request(
    'https://api.intellipush.com/restv2/sms/create',
    data=json.dumps({
        'message': 'Your appointment is confirmed.',
        'countrycode': '+47',
        'phonenumber': '12345678'
    }).encode(),
    headers={'Authorization': f'Bearer {access_token}', 'Content-Type': 'application/json'},
    method='POST'
)
with urlopen(sms_request) as response:
    print(json.load(response))

Technical source checked 16 August 2026: Intellipush REST API, OpenAPI 3.1.

In practice