Intellix Edge API Reference

Welcome to the Intellix Edge API documentation. Our API enables you to programmatically access and manipulate your business intelligence data, create custom integrations, and extend the functionality of the Intellix Edge platform.

API Version

Current API version: v1

All API requests should include the version in the URL path: https://api.intellixedge.com/v1/

RESTful Endpoints

Access your data through our intuitive REST API with JSON responses.

Secure Authentication

Multiple authentication methods including API keys and OAuth 2.0.

Client Libraries

Official SDKs for JavaScript, Python, Ruby, and more.

Webhooks

Real-time notifications for data changes and events.

Base URL

API Endpoint
https://api.intellixedge.com/v1

All API requests must use HTTPS. HTTP requests will be rejected.

Quick Start

Get up and running with the Intellix Edge API in minutes. Follow these steps to make your first API request.

1. Get your API key

Generate an API key from your Intellix Edge dashboard under Settings → API.

1

Navigate to Settings → API in your dashboard

2

Click Generate New API Key

3

Store your API key securely — it won't be shown again

2. Make your first API request

Use your API key to authenticate and make a simple request to verify your setup.

Request 
curl -X GET "https://api.intellixedge.com/v1/dashboards" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"

Response

JSON Response 
{
"data": [
{
"id": "dash_01HGZXK2J5V8ABCDEFGHJK",
"name": "Sales Overview",
"description": "Key sales metrics and trends",
"created_at": "2025-05-15T14:32:18Z",
"updated_at": "2025-06-01T09:17:42Z",
"owner_id": "user_01HGZXK2J5V8LMNOPQRSTU"
},
{
"id": "dash_01HGZXK2J5V8VWXYZABCDE",
"name": "Marketing Performance",
"description": "Campaign metrics and ROI analysis",
"created_at": "2025-05-20T10:15:33Z",
"updated_at": "2025-05-30T16:42:19Z",
"owner_id": "user_01HGZXK2J5V8LMNOPQRSTU"
}
],
"meta": {
"total_count": 2,
"page": 1,
"per_page": 10
}
}

3. Explore the API

Now that you've made your first request, explore the rest of the API documentation to learn about all available endpoints and features.

Authentication Methods
Core Resources
Error Handling
SDKs & Libraries

API Keys

API keys are used to authenticate requests to the Intellix Edge API. Each API key is associated with a specific user and has configurable permissions.

Authentication

Include your API key in the Authorization header of all requests:

Header Format
Authorization: Bearer YOUR_API_KEY

Security Warning

Keep your API keys secure and never expose them in client-side code or public repositories. Rotate your keys regularly and use environment variables to store them in your applications.

Managing API Keys

Creating a new API key

POST /v1/api-keys 
curl -X POST "https://api.intellixedge.com/v1/api-keys" \
-H "Authorization: Bearer YOUR_ADMIN_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"name": "Dashboard Integration",
"expires_in": 90,
"permissions": ["read:dashboards", "write:dashboards"]
}'

Listing your API keys

GET /v1/api-keys 
curl -X GET "https://api.intellixedge.com/v1/api-keys" \
-H "Authorization: Bearer YOUR_ADMIN_API_KEY" \
-H "Content-Type: application/json"

Revoking an API key

DELETE /v1/api-keys/{key_id} 
curl -X DELETE "https://api.intellixedge.com/v1/api-keys/key_01HGZXK2J5V8ABCDEFGHJK" \
-H "Authorization: Bearer YOUR_ADMIN_API_KEY" \
-H "Content-Type: application/json"

Rate Limits

To ensure the stability and performance of the API, Intellix Edge implements rate limiting on API requests. Understanding these limits will help you design your applications to work optimally with our API.

Rate Limit Headers

All API responses include headers that provide information about your current rate limit status:

Header Description
X-RateLimit-Limit The maximum number of requests you're permitted to make per hour
X-RateLimit-Remaining The number of requests remaining in the current rate limit window
X-RateLimit-Reset The time at which the current rate limit window resets in UTC epoch seconds
Example Headers 
HTTP/1.1 200 OK
X-RateLimit-Limit: 5000
X-RateLimit-Remaining: 4997
X-RateLimit-Reset: 1717675425

Rate Limit Tiers

Rate limits vary based on your subscription plan:

Plan Rate Limit (requests per hour) Burst Limit (requests per minute)
Free 1,000 100
Pro 5,000 300
Business 10,000 600
Enterprise Custom Custom

Handling Rate Limits

When you exceed your rate limit, the API will return a 429 Too Many Requests response. Here are some best practices for handling rate limits:

Implement Exponential Backoff

When you receive a 429 response, wait before retrying. Increase the wait time exponentially with each retry.

// JavaScript example
async function makeRequestWithBackoff(url, options, maxRetries = 5) {
let retries = 0;
while (retries < maxRetries) {
try {
const response = await fetch(url, options);
if (response.status !== 429) {
return response;
}
// Get reset time from headers
const resetTime = response.headers.get('X-RateLimit-Reset');
const waitTime = resetTime ?
Math.max(Math.ceil(resetTime - Date.now() / 1000), 0) :
Math.pow(2, retries) * 1000;
console.log(`Rate limited. Waiting ${waitTime}ms before retry.`);
await new Promise(resolve => setTimeout(resolve, waitTime));
retries++;
} catch (error) {
throw error;
}
}
throw new Error('Max retries exceeded');
}

Monitor Your Usage

Track your API usage by checking the rate limit headers in each response. Implement alerts when you approach your limits.

Optimize Your Requests

  • Batch operations when possible
  • Cache responses that don't change frequently
  • Use webhooks for real-time updates instead of polling
  • Implement pagination to retrieve large data sets efficiently

Rate Limit Exceeded Response

429 Too Many Requests Response 
{
"error": {
"code": "rate_limit_exceeded",
"message": "Rate limit exceeded. Please wait and try again later.",
"retry_after": 35
}
}

JavaScript SDK

The Intellix Edge JavaScript SDK provides a convenient way to interact with our API from browser and Node.js environments.

Installation

npm 
npm install @intellix-edge/sdk
yarn 
yarn add @intellix-edge/sdk

Quick Start

JavaScript 
import { IntellixEdge } from '@intellix-edge/sdk';
// Initialize the client
const intellix = new IntellixEdge({
apiKey: 'YOUR_API_KEY',
// Optional configuration
baseUrl: 'https://api.intellixedge.com/v1',
timeout: 30000, // 30 seconds
});
// Example: List dashboards
async function listDashboards() {
try {
const { data, meta } = await intellix.dashboards.list({
page: 1,
per_page: 10,
sort: 'updated_at:desc'
});
console.log(`Found ${meta.total_count} dashboards`);
data.forEach(dashboard => {
console.log(`- ${dashboard.name}`);
});
} catch (error) {
console.error('Error fetching dashboards:', error);
}
}
// Example: Create a dashboard
async function createDashboard() {
try {
const { data } = await intellix.dashboards.create({
name: 'New Dashboard',
description: 'Created via the JavaScript SDK',
is_public: false
});
console.log(`Created dashboard with ID: ${data.id}`);
return data;
} catch (error) {
console.error('Error creating dashboard:', error);
}
}
// Example: Add a visualization to a dashboard
async function addVisualization(dashboardId, queryId) {
try {
// First create a visualization from a query
const { data: visualization } = await intellix.visualizations.create({
name: 'Monthly Revenue',
query_id: queryId,
type: 'line_chart',
options: {
x_axis: 'month',
y_axis: 'revenue',
show_legend: true
}
});
// Then add it to the dashboard
const { data } = await intellix.dashboards.update(dashboardId, {
visualizations: [visualization.id]
});
console.log('Visualization added to dashboard');
return data;
} catch (error) {
console.error('Error adding visualization:', error);
}
}

Error Handling

The SDK provides structured error handling for API errors:

JavaScript 
import { IntellixEdge, ApiError, RateLimitError } from '@intellix-edge/sdk';
const intellix = new IntellixEdge({
apiKey: 'YOUR_API_KEY'
});
async function handleErrors() {
try {
const result = await intellix.dashboards.get('non_existent_id');
return result;
} catch (error) {
if (error instanceof RateLimitError) {
console.error(`Rate limit exceeded. Retry after ${error.retryAfter} seconds`);
// Implement retry logic
} else if (error instanceof ApiError) {
console.error(`API Error: ${error.code} - ${error.message}`);
console.error(`Status: ${error.statusCode}`);
console.error(`Request ID: ${error.requestId}`);
} else {
console.error('Unexpected error:', error);
}
}
}

Webhooks

Webhooks allow you to receive real-time notifications when specific events occur in your Intellix Edge account. Instead of polling the API for changes, webhooks push data to your application as events happen.

Available Events

You can subscribe to the following webhook events:

Event Description
dashboard.created A new dashboard has been created
dashboard.updated A dashboard has been updated
dashboard.deleted A dashboard has been deleted
visualization.created A new visualization has been created
data_source.connected A new data source has been connected
data_source.sync_completed A data source sync has completed
alert.triggered A data alert has been triggered
user.invited A new user has been invited to your organization

Creating a Webhook Endpoint

To create a webhook endpoint, you'll need to:

  1. 1

    Set up a publicly accessible HTTPS endpoint on your server

    Your endpoint should be able to process POST requests and respond with a 200 status code

  2. 2

    Register your endpoint with the Intellix Edge API

    Use the API to create a webhook subscription for specific events

  3. 3

    Verify your endpoint

    We'll send a verification request to your endpoint with a challenge parameter

  4. 4

    Implement signature verification

    Verify that incoming webhook requests are legitimate by checking the signature

POST /v1/webhooks 
curl -X POST "https://api.intellixedge.com/v1/webhooks" \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://your-server.com/webhooks/intellix",
"events": ["dashboard.created", "dashboard.updated", "alert.triggered"],
"description": "Dashboard and alert notifications",
"active": true
}'

Response

201 Created Response 
{
"data": {
"id": "webhook_01HGZXK2J5V8ABCDEFGHJK",
"url": "https://your-server.com/webhooks/intellix",
"events": ["dashboard.created", "dashboard.updated", "alert.triggered"],
"description": "Dashboard and alert notifications",
"active": true,
"created_at": "2025-06-05T11:32:45Z",
"updated_at": "2025-06-05T11:32:45Z",
"secret": "whsec_abcdefghijklmnopqrstuvwxyz123456" // Store this securely
}
}

Webhook Payload Format

When an event occurs, we'll send a POST request to your endpoint with the following payload structure:

Example Webhook Payload 
{
"id": "evt_01HGZXK2J5V8ABCDEFGHJK",
"type": "dashboard.created",
"created_at": "2025-06-05T14:23:45Z",
"data": {
"id": "dash_01HGZXK2J5V8KLMNOPQRST",
"name": "Sales Performance Q2",
"description": "Quarterly sales performance metrics",
"created_at": "2025-06-05T14:23:42Z",
"updated_at": "2025-06-05T14:23:42Z",
"owner_id": "user_01HGZXK2J5V8LMNOPQRSTU",
"is_public": false
}
}

Verifying Webhook Signatures

To ensure that webhook requests are coming from Intellix Edge, you should verify the signature included in each request:

Node.js Example 
const crypto = require('crypto');
const express = require('express');
const app = express();
// Your webhook secret from the webhook creation response
const webhookSecret = 'whsec_abcdefghijklmnopqrstuvwxyz123456';
app.use(express.json({
verify: (req, res, buf) => {
req.rawBody = buf.toString();
}
}));
app.post('/webhooks/intellix', (req, res) => {
const signature = req.headers['x-intellix-signature'];
const timestamp = req.headers['x-intellix-timestamp'];
if (!signature || !timestamp) {
return res.status(400).send('Missing signature or timestamp');
}
// Check if the timestamp is recent (within 5 minutes)
const now = Math.floor(Date.now() / 1000);
if (Math.abs(now - parseInt(timestamp)) > 300) {
return res.status(400).send('Timestamp too old');
}
// Compute expected signature
const payload = `${timestamp}.${req.rawBody}`;
const expectedSignature = crypto
.createHmac('sha256', webhookSecret)
.update(payload)
.digest('hex');
// Compare signatures using a timing-safe comparison
if (!crypto.timingSafeEqual(
Buffer.from(signature),
Buffer.from(expectedSignature)
)) {
return res.status(401).send('Invalid signature');
}
// Signature is valid, process the webhook
const event = req.body;
console.log(`Received event: ${event.type}`);
// Handle different event types
switch (event.type) {
case 'dashboard.created':
console.log(`New dashboard created: ${event.data.name}`);
break;
case 'alert.triggered':
console.log(`Alert triggered: ${event.data.name}`);
break;
// Handle other event types
}
// Return a 200 response to acknowledge receipt
res.status(200).send('Webhook received');
});
app.listen(3000, () => {
console.log('Webhook server running on port 3000');
});