API & MCP

Quick start

1. 1. Create a key. An administrator opens Settings → API Keys, names the key, ticks only the access it needs, picks an expiry and clicks Generate Key. Copy it: it is shown once.
2. 2. Store it as a secret. Use your secret manager or environment variables. Never put it in browser code or a repository.
3. 3. Call the API or connect an MCP client (examples below).

curl https://app.inferoniq.com/api/query \
  -H "x-api-key: ik_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "How many open orders were created last month?"}'

Authentication & keys

inferonIQ uses API keys for machine access. There is no client ID / client secret exchange and no access or refresh tokens to manage: send the key on every request. Keys are stored only as a one-way hash, so a lost key cannot be recovered — rotate it instead.

• A key never has more access than a power user: it cannot manage users, settings or other keys.
• A key with only view/export is read-only: any write is refused (MCP excepted, where each tool checks its scope).
• Keys reach only the modules your plan includes, like a signed-in user.
• Expiry: 30, 90 or 365 days, or none. Rotate issues a new key with the same access and stops the old one immediately. Revoke stops a key on its next request.
• A key stops working if the administrator who created it is removed or disabled. Use a dedicated integration account for long-lived keys.

MCP server

Endpoint https://app.inferoniq.com/api/mcp — Streamable HTTP, protocol versions 2025-06-18, 2025-03-26 and 2024-11-05. Your assistant’s model does the conversation; inferonIQ answers through these read-only tools:

claude mcp add --transport http inferoniq https://app.inferoniq.com/api/mcp \
  --header "x-api-key: ik_live_YOUR_KEY"

// .vscode/mcp.json
{
  "inputs": [
    { "type": "promptString", "id": "inferoniq-key", "description": "inferonIQ API key", "password": true }
  ],
  "servers": {
    "inferoniq": {
      "type": "http",
      "url": "https://app.inferoniq.com/api/mcp",
      "headers": { "x-api-key": "${input:inferoniq-key}" }
    }
  }
}

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "inferoniq": {
      "url": "https://app.inferoniq.com/api/mcp",
      "headers": { "x-api-key": "ik_live_YOUR_KEY" }
    }
  }
}

// claude_desktop_config.json — bridges to the remote server with mcp-remote
{
  "mcpServers": {
    "inferoniq": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://app.inferoniq.com/api/mcp", "--header", "Authorization:${AUTH}"],
      "env": { "AUTH": "Bearer ik_live_YOUR_KEY" }
    }
  }
}

Assistants that only connect through an OAuth sign-in (for example web-based connector directories) are not supported yet.

Ask from Microsoft Teams or Slack

People can ask inferonIQ questions where they already work. The answer is computed by inferonIQ (same governed, read-only path as the app); the chat app only carries the question and shows the result.

Microsoft Teams (with Microsoft Copilot Studio)

For organizations licensed for Copilot Studio. No code and no app-store listing: the agent is published to your own tenant.

1. Before you start: a work or school Microsoft account (personal outlook.com accounts cannot use Copilot Studio) and a Copilot Studio environment with credits — every message, in testing and in Teams, uses them.
2. In inferonIQ, an administrator creates a key for the team that will use the agent (Settings → API Keys): tick only Read and Run queries, choose an expiry.
3. In Copilot Studio, create an agent (for example “inferonIQ Finance”) and add instructions: “For any question about our business data, call the inferonIQ ask tool. Show its answer and table_markdown as returned; quote numbers exactly. If inferonIQ cannot answer, say so; never answer data questions from your own knowledge or the web.”
4. Under Knowledge, remove “Search all websites” so answers come only from inferonIQ.
5. Under Tools select + → Model Context Protocol. Server URL https://app.inferoniq.com/api/mcp (or your self-hosted URL). Authentication: API key, type Header, header name x-api-key. Create a new connection with the key and Add to agent; three tools appear (list_sources, describe_tables, ask).
6. Test in Preview with questions you can check in inferonIQ, plus one your data cannot answer (the agent must say so, not guess).
7. Channels → Microsoft Teams → Publish, then open it with “Open in Teams”. Your Teams administrator approves the agent for the people who should use it.

Slack

• An AI assistant your team already uses in Slack that supports remote MCP servers connects with the same URL and key as above.
• Or your developers add a small Slack app that calls the REST API, for example a /ask command:

// Slack slash command /ask, built with Bolt for JavaScript (runs on your server)
app.command('/ask', async ({ command, ack, respond }) => {
  await ack()                                   // Slack needs a reply within 3 seconds
  const res = await fetch('https://app.inferoniq.com/api/query', {
    method: 'POST',
    headers: { 'x-api-key': process.env.INFERONIQ_API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({ query: command.text }),
    signal: AbortSignal.timeout(60_000),
  })
  const body = await res.json()
  if (!res.ok || body.error) return respond(`inferonIQ could not answer: ${body.message ?? body.error}`)
  await respond(`*${command.text}*\n${body.answer}\n_${body.rowCount} rows · tables: ${(body.tablesUsed ?? []).join(', ')}_`)
})

Before you roll out

• Everyone using one agent or bot shares its key’s access. Create one key and one agent per team (for example AP, Finance) so each group sees only what its key allows.
• The chat assistant writes the final message. The result includes the SQL and the tables used so answers can be checked; open the question in inferonIQ for the full result.
• Answers are stored in your Teams or Slack history. Do not use these channels for patient-level or other regulated detail; ask for counts and totals instead.
• An inferonIQ app for Teams and Slack with per-person sign-in is available on request.

Rate limits, paging & errors

• 600 requests per minute per key. Over the limit you get 429 with Retry-After (seconds). An MCP ask counts as two requests.
• Monthly question and document allowances follow your plan (pricing).
• Paging: lists take limit and offset (or a cursor where noted) and return the next position. Questions return up to 200 rows plus the total row count — narrow the question for more detail.
• Requests can take up to 60 seconds for complex questions; set client timeouts accordingly.

MCP Server

One endpoint for MCP clients (Claude, Copilot, Cursor and others). JSON-RPC 2.0 over Streamable HTTP; responses are returned on the POST.

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{ \"answer\": \"…\", \"sql\": \"SELECT …\", \"rows\": [ … ] }"
      }
    ],
    "structuredContent": {
      "answer": "…",
      "sql": "SELECT COUNT(*) …",
      "columns": [
        "count"
      ],
      "rows": [
        {
          "count": 412
        }
      ],
      "row_count": 1,
      "rows_truncated": false,
      "confidence": 0.93,
      "tables_used": [
        "orders"
      ],
      "query_id": "…"
    }
  }
}

API Keys

Create and manage keys (administrators, signed in to the app). Keys cannot manage keys, users or settings.

{
  "key": "ik_live_…",
  "id": "…",
  "prefix": "ik_live_a1b2",
  "permissions": [
    "view",
    "run_queries"
  ],
  "expires_at": "2027-01-08T00:00:00Z"
}

NL2SQL Query

Execute natural language questions against connected databases.

{
  "answer": "412 open orders were created last month.",
  "sql": "SELECT COUNT(*) ...",
  "data": [
    {
      "count": 412
    }
  ],
  "columns": [
    "count"
  ],
  "rowCount": 1,
  "confidence": 0.94,
  "tablesUsed": [
    "orders"
  ],
  "queryId": "…"
}

Documents

Upload, classify, and extract data from invoices, contracts, and receipts.

{
  "uploadUrl": "https://storage...",
  "storagePath": "customer_id/file.pdf",
  "expiresIn": 600
}

{
  "id": "doc-uuid",
  "type": "invoice",
  "extractedFields": {
    "vendor": "Acme",
    "total": 14805
  }
}

Connections

Manage database and storage connections.

3-Way Matching

Invoice ↔ Purchase Order ↔ Goods Receipt reconciliation.

{
  "matchResult": "3-way",
  "confidence": 0.97,
  "exceptions": [],
  "autoApproved": true
}

Contracts

Contract intelligence — clause extraction and compliance monitoring.

License

License validation and usage information.

{
  "plan": "business",
  "status": "active",
  "expiresAt": "2027-01-01",
  "usage": {
    "queries": 1250,
    "limit": 25000
  }
}

Health

Platform health and connectivity checks.

{
  "status": "healthy",
  "version": "3.7.0",
  "database": "connected"
}

Rate Limits & Usage