1. Authenticate
Create the required access and obtain an OAuth 2.0 token from the documentation.
Denne siden finnes også på norsk.
Developer guide
Get started with the REST API, OAuth 2.0 and open developer documentation. API access is included with every Intellipush account.
Create the required access and obtain an OAuth 2.0 token from the documentation.
Follow the documentation for recipient, sender and message content.
Retain relevant technical references and handle failures explicitly.
Practical overview
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
Make each stage observable without turning message content or personal data into default log output.
Follow the documentation for account and API access. Decide which environments and people genuinely need the credentials.
Use OAuth 2.0 as documented. Store tokens and client secrets securely, rotate them when required and never commit them to a public repository.
Validate recipient, sender and text before the call. Use documented fields, and include a safeguard against unintended bulk delivery.
Handle both accepted requests and errors. Retain correlation or reference values required for diagnosis without copying the entire message into logs.
Test valid and invalid numbers, character sets, long messages, service unavailability and retries. Begin with your own recipients and a low volume.
Limit access and volume, monitor failures in a privacy-conscious way and document who responds when the integration stops.
We serve businesses in Norway and Europe. SMS destinations, sender types and optional features must be checked for the country and account setup you intend to use.
Runnable quickstart
These examples follow the current OpenAPI contract. Replace only the environment variables and use a test number you control.
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.
export INTELLIPUSH_API_ID="your_api_id"
export INTELLIPUSH_API_SECRET="your_api_secret"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 --request POST \
--url https://api.intellipush.com/restv2/token \
--user "$INTELLIPUSH_API_ID:$INTELLIPUSH_API_SECRET" \
--header "Content-Type: application/x-www-form-urlencoded" \
--data-urlencode "grant_type=client_credentials"{
"access_token": "ip_at_example_opaque_token_not_for_authentication",
"expires_in": 3600,
"token_type": "Bearer",
"scope": ""
}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.
export INTELLIPUSH_ACCESS_TOKEN="your_access_token"
# Persist one unique key per logical send; reuse only for the same payload.
export INTELLIPUSH_IDEMPOTENCY_KEY="your_persisted_unique_send_key"
curl --request POST \
--url https://api.intellipush.com/restv2/sms/create \
--header "Idempotency-Key: $INTELLIPUSH_IDEMPOTENCY_KEY" \
--header "Authorization: Bearer $INTELLIPUSH_ACCESS_TOKEN" \
--header "Content-Type: application/json" \
--data '{
"message": "Your appointment is confirmed.",
"countrycode": "+47",
"phonenumber": "12345678"
}'{
"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."
}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 --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 examples use environment variables and send one real SMS. Persist one unique key per logical send before the first attempt; reuse it only with an identical request.
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/restv2/token', {
method: 'POST',
headers: {
Authorization: `Basic ${basic}`,
'Content-Type': 'application/x-www-form-urlencoded'
},
body: new URLSearchParams({ grant_type: 'client_credentials' }),
signal: AbortSignal.timeout(30000)
});
if (!tokenResponse.ok) throw new Error(`Token request failed (${tokenResponse.status})`);
const { access_token } = await tokenResponse.json();
const sendKey = process.env.INTELLIPUSH_IDEMPOTENCY_KEY;
if (!sendKey) throw new Error('Missing persisted send key');
const smsResponse = await fetch('https://api.intellipush.com/restv2/sms/create', {
method: 'POST',
headers: {
Authorization: `Bearer ${access_token}`,
'Idempotency-Key': sendKey,
'Content-Type': 'application/json'
},
body: JSON.stringify({
message: 'Your appointment is confirmed.',
countrycode: '+47',
phonenumber: '12345678'
}),
signal: AbortSignal.timeout(30000)
});
if (!smsResponse.ok) throw new Error(`SMS request failed (${smsResponse.status})`);
const result = await smsResponse.json();
if (result.success === false) throw new Error('SMS request rejected');
console.log('SMS request accepted'); // Do not log recipient data or message bodies.import base64
import json
import os
from urllib.parse import urlencode
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/restv2/token',
data=urlencode({'grant_type': 'client_credentials'}).encode(),
headers={'Authorization': f'Basic {basic}', 'Content-Type': 'application/x-www-form-urlencoded'},
method='POST'
)
with urlopen(token_request, timeout=30) 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',
'Idempotency-Key': os.environ['INTELLIPUSH_IDEMPOTENCY_KEY']},
method='POST'
)
with urlopen(sms_request, timeout=30) as response:
result = json.load(response)
if result.get('success') is False:
raise RuntimeError('SMS request rejected')
print('SMS request accepted') # Do not log recipient data or message bodies.Read the operating plan for 409 responses, uncertain outcomes and delivery status →
The token is opaque, valid for 3,600 seconds, with no refresh token. HTTP status is authoritative; status_message is not a stable machine code. Distinguish HTTP status from delivery codes. Also handle 403, 405 and 409. Do not automatically retry an uncertain creation request without documented idempotency: persist one unique key per logical send and reuse the same key and identical payload for retries within 24 hours.
Technical source checked 30 October 2026: Intellipush REST API 1.8.0, OpenAPI 3.1.2. Read the raw OpenAPI specification (YAML)
In practice
Check data and text early, then use the API documentation for the technical contract.
Normalise international numbers before they become part of a request.
See how character set and content affect the number of SMS segments.
Contact Intellipush when solution design, volume or the intended workflow needs review.
Tools
Open the tools without downloading software.

Validate and normalise phone numbers before importing contacts or sending messages.
Open tool
Check character count, encoding and SMS segments before you send.
Open tool
Clean phone number lists and prepare them for import.
Open toolGet started
Create an account for free and use the portal or API. Buy SMS credits when you are ready to send — with no monthly platform fee or lock-in.