Every CoreNexis API, inside your AI agent

1. What this is

The Model Context Protocol is the standard way an AI assistant discovers and uses outside tools. This server speaks it, and every CoreNexis API appears through it as a tool your agent can call by name.

The important thing to understand is what this server does not do. It holds no credentials and grants no access of its own. When your agent calls a tool, this server makes the same REST request you could have made yourself, using your API key, and the API being called decides everything: whether the key is valid, whether your account is subscribed, and whether your quota allows it. A key that works over REST works here, and one that does not is refused here in the same way and for the same reason.

2. Before you start

Two things, both free to begin with.

Get an API key

Create one at dash.corenexis.com/api-keys. A key belongs to your account rather than to one API, so a single key is all you ever need here.

Subscribe to the APIs you want to use

Each API is subscribed to separately, and most have a free tier. Your key will only work for the APIs it is subscribed to, which is the single most common surprise when setting this up: the server connects and lists every tool, then one particular tool refuses the call. That refusal names the API and links you straight to its subscribe page.

3. The endpoint

POSThttps://api.corenexis.com/mcp/server

It uses the Streamable HTTP transport, which is what current MCP clients speak. There is nothing to install and no separate process to run: point your client at the address above and it works.

4. Authentication

Send your API key exactly as you would to any CoreNexis REST endpoint.

x-api-key: your_api_key

Some clients can only send a bearer token, and a few cannot set headers at all. Both are accommodated, in this order of preference:

If no key reaches the server, connecting fails immediately with a message saying what to add and where to get it, rather than appearing to work and then failing on the first real call.

5. Connect your agent

Pick the one you use. The address and the key are the same everywhere.

Claude

In Claude Desktop or Claude Code, add the server to your MCP configuration file.

{
  "mcpServers": {
    "corenexis": {
      "type": "http",
      "url": "https://api.corenexis.com/mcp/server",
      "headers": {
        "x-api-key": "your_api_key"
      }
    }
  }
}

Restart the app. The CoreNexis tools appear in the tool list, and you can then simply ask for what you want: "turn this Markdown into a PDF", or "read the text out of this image".

n8n

Use the MCP Client node.

Attach the node to an AI Agent node and the tools become available to it. If your version of the node offers no header field, use the query string form of the URL instead.

Any other agent or framework

Anything that speaks MCP over HTTP will work. The shape of the configuration is always the same: an address, and one header.

{
  "name": "corenexis",
  "transport": "streamable-http",
  "url": "https://api.corenexis.com/mcp/server",
  "headers": { "x-api-key": "your_api_key" }
}

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

URL = "https://api.corenexis.com/mcp/server"
HEADERS = {"x-api-key": "your_api_key"}

async with streamablehttp_client(URL, headers=HEADERS) as (read, write, _):
    async with ClientSession(read, write) as session:
        await session.initialize()
        tools = await session.list_tools()
        print([t.name for t in tools.tools])

        result = await session.call_tool(
            "email_validate", {"email": "someone@example.com"}
        )
        print(result.content[0].text)

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport }
  from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://api.corenexis.com/mcp/server"),
  { requestInit: { headers: { "x-api-key": "your_api_key" } } }
);

const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log(tools.tools.map(t => t.name));

const out = await client.callTool({
  name: "markdown_to_pdf",
  arguments: { markdown: "# Invoice\n\nThank you." }
});
console.log(out.content[0].text);

6. Available APIs

All 9+ CoreNexis APIs are reachable through the server. Each one is subscribed to separately; the last column is where to do that.

7. Tool reference

14 tools in total. Argument names match the REST parameters exactly, so anything written against an API's own documentation works here unchanged.

8. Sending files and images

A tool call carries JSON, not bytes. There is no field anywhere in the Model Context Protocol that a raw file can be poured into, so an agent cannot hand a local file straight to a tool. That is worth knowing before you try, because the failure looks like a missing parameter rather than a limit of the protocol.

There are three ways to get a file in, and which ones a tool accepts depends on the API behind it.

1. A public URL, whenever you have one

Always the best option. Nothing large travels through the conversation, and every file-taking tool accepts one.

2. Base64, for a small local file

Encode the bytes and pass them in the base64 field. A data URI prefix is fine and is stripped for you. Two things to keep in mind: base64 is about a third larger than the file, and every byte of it passes through the model's context, so keep this for files of a few megabytes at most.

3. The chain, when a tool wants a URL and you only have bytes

The QR image mode takes a URL and nothing else. The way round it is image_cdn_upload or image_convert: both accept base64 and return a hosted link, which then satisfies anything that wants a URL:

// 1. bytes in, hosted link out
image_cdn_upload { "image_base64": "iVBORw0KGgo..." }
   -> { "data": { "url": "https://cdn.corenexis.com/..." } }

// 2. that link now works anywhere a URL is wanted
qr_barcode_generate { "type": "image", "image_url": "https://cdn.corenexis.com/..." }

Each call spends one request from that API's quota, so the chain costs two.

4. Straight to REST, for anything large

The APIs themselves accept ordinary multipart uploads, and nothing stops you using them directly for the upload and the MCP tools for everything else. This is the right route for a large PDF or a high resolution photograph.

curl -X POST "https://api.corenexis.com/image-cdn/v3" \
  -H "x-api-key: your_api_key" \
  -F "image=@/path/to/photo.jpg"

Take the url out of the response and give that to any tool.

9. Try it with curl

Useful for confirming a key works before wiring up an agent.

List the tools

curl -X POST "https://api.corenexis.com/mcp/server" \
  -H "x-api-key: your_api_key" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Call a tool

curl -X POST "https://api.corenexis.com/mcp/server" \
  -H "x-api-key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call",
       "params":{"name":"email_validate",
                 "arguments":{"email":"someone@example.com"}}}'

Check what your key can reach

curl -X POST "https://api.corenexis.com/mcp/server" \
  -H "x-api-key: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call",
       "params":{"name":"corenexis_api_details",
                 "arguments":{"api":"markdown-to-pdf"}}}'

10. Errors and what to do

A failed tool call comes back as a readable sentence rather than a code, so an agent can act on it instead of retrying the same failing call. These are the ones you are likely to meet.

11. Status and version

The health endpoint is public and needs no key, precisely because the moment you want it is when your credentials are in doubt. It answers 200 with a small JSON body while the server is serving, and is cheap enough to poll from a monitor.

GEThttps://api.corenexis.com/mcp/health

{
  "status": "up",
  "service": "CoreNexis MCP server",
  "version": "1.0.0",
  "endpoint": "https://api.corenexis.com/mcp/server",
  "transport": "streamable-http",
  "protocol": "2025-06-18",
  "apis": 9,
  "tools": 14,
  "checked_at": "2026-10-01T08:13:12+00:00"
}

12. Questions