Fuses API

Send one query across multiple AI models concurrently, streams their responses, and generates a summary that highlights agreements and differences.

One Integration

Connect once and query multiple AI models through one API key.

See supported models

Low Latency & Scale

Query models concurrenctly and stream responses back with low latency from global edge workers.

Summary + Data

Clear response summary noting agreements and differences. Data formatted in tables for easy extraction.

Endpoints

POST/api/query

Run a query against multiple AI models concurrently. Streams one or more responses and optional summary from the selected models.

GET/api/models

List available models and information like pricing, context window limits, and knowledge cutoff dates.

POST/api/memory

Create or update a durable memory. Returns memory metadata.

Query multiple models & summarize outputs

Prompt one or more AI models with your query. Returns each model's response along with an optional summary that highlights differences and agreements across the models.

POST`/api/query`

curl https://fuses.ai/api/query \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "query": "Summarize the latest changes in the AI model market.",
    "models": ["gpt-4o", "claude-sonnet-4", "grok-4.3"],
    "summary": true,
    "stream": false
  }'

const response = await fetch("https://fuses.ai/api/query", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer YOUR_API_KEY",
  },
  body: JSON.stringify({
    query: "Summarize the latest changes in the AI model market.",
    models: ["gpt-4o", "claude-sonnet-4", "grok-4.3"],
    summary: true,
    stream: false,
  }),
});

const data = await response.json();

console.log(data.summary?.output);
console.log(data.responses);

$payload = [
    "query" => "Summarize the latest changes in the AI model market.",
    "models" => ["gpt-4o", "claude-sonnet-4", "grok-4.3"],
    "summary" => true,
    "stream" => false,
];

$ch = curl_init("https://fuses.ai/api/query");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "Authorization: Bearer YOUR_API_KEY",
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
]);

$result = curl_exec($ch);
$data = json_decode($result, true);

echo $data["summary"]["output"];

import requests

response = requests.post(
    "https://fuses.ai/api/query",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "query": "Summarize the latest changes in the AI model market.",
        "models": ["gpt-4o", "claude-sonnet-4", "grok-4.3"],
        "summary": True,
        "stream": False,
    },
)

data = response.json()
print(data["summary"]["output"])
print(data["responses"])

require "net/http"
require "json"

uri = URI("https://fuses.ai/api/query")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer YOUR_API_KEY"
request.body = {
  query: "Summarize the latest changes in the AI model market.",
  models: ["gpt-4o", "claude-sonnet-4", "grok-4.3"],
  summary: true,
  stream: false
}.to_json

response = http.request(request)
data = JSON.parse(response.body)

puts data["summary"]["output"]
puts data["responses"]

const response = await fetch("https://fuses.ai/api/query", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer YOUR_API_KEY",
  },
  body: JSON.stringify({
    query: "Summarize the latest changes in the AI model market.",
    models: ["gpt-4o", "claude-sonnet-4", "grok-4.3"],
    summary: true,
    stream: false,
  }),
});

const data = await response.json();

console.log(data.summary?.output);
console.log(data.responses);

Request params

Field	Type	Description
query	string	The input text to prompt to the selected models.
models	string[]	One or more model slugs, such as `gpt-5.4` or `grok-4.3`.
summary	boolean	When `true`, Fuses also returns a synthesized response that highlights agreements and notes meaningful differences across the model outputs.
stream	boolean	When `false`, return one final JSON response. When `true`, stream the response body back over the same `POST`.

Query multiple models — Sample response

Responses include request metadata like tokens consumed, responses for each model, and optional summary.

{
  "id": "req_8f3m2k1q",
  "query": "Summarize the latest changes in the AI model market.",
  "models": ["gpt-4o", "claude-sonnet-4", "grok-4.3"],
  "responses": [
    {
      "model": "gpt-4o",
      "status": "completed",
      "output": "OpenAI expanded enterprise controls and refreshed pricing..."
    },
    {
      "model": "claude-sonnet-4",
      "status": "completed",
      "output": "Anthropic focused on coding quality, reliability, and tooling..."
    },
    {
      "model": "grok-4.3",
      "status": "completed",
      "output": "xAI continued pushing real-time positioning and long-context use cases..."
    }
  ],
  "summary": {
    "status": "completed",
    "output": "Across providers, the main themes are enterprise controls, coding quality, and differentiation through context and tooling."
  },
  "usage": {
    "inputTokens": 1811,
    "outputTokens": 2642
  }
}

Sample Streaming request — Query multiple models

Set stream to true for lower perceived latency when your UI can render chunks as they arrive.

curl -N https://fuses.ai/api/query \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept: application/x-ndjson" \
  -d '{
    "query": "what is the tallest peak on earth",
    "models": ["gpt-5.4", "claude-sonnet-4-6", "mistral-small-3.1"],
    "summary": true,
    "stream": true
  }'

const response = await fetch("https://fuses.ai/api/query", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer YOUR_API_KEY",
    Accept: "application/x-ndjson",
  },
  body: JSON.stringify({
    query: "what is the tallest peak on earth",
    models: ["gpt-5.4", "claude-sonnet-4-6", "mistral-small-3.1"],
    summary: true,
    stream: true,
  }),
});

$payload = [
    "query" => "what is the tallest peak on earth",
    "models" => ["gpt-5.4", "claude-sonnet-4-6", "mistral-small-3.1"],
    "summary" => true,
    "stream" => true,
];

$ch = curl_init("https://fuses.ai/api/query");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "Authorization: Bearer YOUR_API_KEY",
        "Accept: application/x-ndjson",
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
]);

curl_exec($ch);

import requests

response = requests.post(
    "https://fuses.ai/api/query",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Accept": "application/x-ndjson",
    },
    json={
        "query": "what is the tallest peak on earth",
        "models": ["gpt-5.4", "claude-sonnet-4-6", "mistral-small-3.1"],
        "summary": True,
        "stream": True,
    },
    stream=True,
)

for line in response.iter_lines():
    if line:
        print(line.decode())

require "net/http"
require "json"

uri = URI("https://fuses.ai/api/query")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer YOUR_API_KEY"
request["Accept"] = "application/x-ndjson"
request.body = {
  query: "what is the tallest peak on earth",
  models: ["gpt-5.4", "claude-sonnet-4-6", "mistral-small-3.1"],
  summary: true,
  stream: true
}.to_json

http.request(request) do |response|
  response.read_body { |chunk| puts chunk }
end

const response = await fetch("https://fuses.ai/api/query", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer YOUR_API_KEY",
    Accept: "application/x-ndjson",
  },
  body: JSON.stringify({
    query: "what is the tallest peak on earth",
    models: ["gpt-5.4", "claude-sonnet-4-6", "mistral-small-3.1"],
    summary: true,
    stream: true,
  }),
});

Streaming response

Streaming responses are newline-delimited JSON (application/x-ndjson). Each line is one event: meta, start, delta, stop, or done. Timing offsets (t) are milliseconds since startedAt.

{"type":"meta","requestId":"req_HM7X","startedAt":"2026-05-25T15:11:42.847Z","models":["gpt-5.4","claude-sonnet-4-6","mistral-small-3.1"]}
{"type":"start","model":"mistral-small-3.1","t":7}
{"type":"start","model":"gpt-5.4","t":9}
{"type":"start","model":"claude-sonnet-4-6","t":12}
{"type":"delta","model":"mistral-small-3.1","text":"The tallest peak"}
{"type":"delta","model":"gpt-5.4","text":"Mount Everest"}
{"type":"delta","model":"mistral-small-3.1","text":" on Earth depends on"}
{"type":"delta","model":"claude-sonnet-4-6","text":"It depends on"}
{"type":"delta","model":"gpt-5.4","text":" is the tallest peak"}
{"type":"delta","model":"mistral-small-3.1","text":" how you measure"}
{"type":"delta","model":"claude-sonnet-4-6","text":" how you define \"tallest\""}
{"type":"delta","model":"gpt-5.4","text":" on Earth, standing at"}
{"type":"delta","model":"mistral-small-3.1","text":". Measured by elevation"}
{"type":"delta","model":"gpt-5.4","text":" 8,848 m (29,029 ft)"}
{"type":"delta","model":"mistral-small-3.1","text":" above sea level,"}
{"type":"delta","model":"claude-sonnet-4-6","text":". By elevation above sea level,"}
{"type":"delta","model":"mistral-small-3.1","text":" Mount Everest at 8,848 m"}
{"type":"delta","model":"gpt-5.4","text":" above sea level in the"}
{"type":"delta","model":"claude-sonnet-4-6","text":" Everest is the tallest."}
{"type":"delta","model":"gpt-5.4","text":" Himalayas on the Nepal-Tibet border."}
{"type":"delta","model":"mistral-small-3.1","text":" is the tallest."}
{"type":"stop","model":"mistral-small-3.1","t":3142,"usage":{"in":12,"out":214}}
{"type":"stop","model":"gpt-5.4","t":4011,"usage":{"in":12,"out":238}}
{"type":"stop","model":"claude-sonnet-4-6","t":4527,"usage":{"in":12,"out":221}}
{"type":"start","model":"summary","t":4530}
{"type":"delta","model":"summary","text":"All three models converge on Mount Everest"}
{"type":"delta","model":"summary","text":" (8,848 m / 29,029 ft above sea level)"}
{"type":"delta","model":"summary","text":" as the tallest peak by elevation."}
{"type":"delta","model":"summary","text":" Two models note that Mauna Kea"}
{"type":"delta","model":"summary","text":" is taller measured base-to-summit (~10,210 m)."}
{"type":"stop","model":"summary","t":5840,"usage":{"in":640,"out":98}}
{"type":"done","t":5842,"totalUsage":{"in":676,"out":771}}

List available models

Returns a list of available AI models on Fuses.ai and their capabilities and costs.

GET`/api/models`

curl https://fuses.ai/api/models \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch("https://fuses.ai/api/models", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const models = await response.json();

console.log(models);

$ch = curl_init("https://fuses.ai/api/models");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOUR_API_KEY",
    ],
]);

$result = curl_exec($ch);
$models = json_decode($result, true);

print_r($models);

import requests

response = requests.get(
    "https://fuses.ai/api/models",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)

models = response.json()
print(models)

require "net/http"
require "json"

uri = URI("https://fuses.ai/api/models")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"

response = http.request(request)
models = JSON.parse(response.body)

puts models

const response = await fetch("https://fuses.ai/api/models", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const models = await response.json();

console.log(models);

Sample response

{
  "models": [
    {
      "id": "gpt-5.4",
      "name": "GPT-5.4",
      "provider": "openai",
      "contextWindow": 128000,
      "knowledgeCutoffDate": "2025-08-31"
    },
    {
      "id": "claude-sonnet-4",
      "name": "Claude Sonnet 4",
      "provider": "anthropic",
      "contextWindow": 200000,
      "knowledgeCutoffDate": "2025-05-01"
    },
    {
      "id": "grok-4.3",
      "name": "Grok 4.3",
      "provider": "xai",
      "contextWindow": 131072
    }
  ]
}

Create a new memory

Store provided content and metadata to durable memory. Returns a new memory ID.

POST`/api/memory`

curl https://fuses.ai/api/memory \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "content": "User prefers terse technical answers and works in TypeScript.",
    "metadata": {
      "userId": "user:4269",
      "source": "onboarding"
    }
  }'

const response = await fetch("https://fuses.ai/api/memory", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer YOUR_API_KEY",
  },
  body: JSON.stringify({
    content: "User prefers terse technical answers and works in TypeScript.",
    metadata: {
      userId: "user:4269",
      source: "onboarding",
    },
  }),
});

const memory = await response.json();

console.log(memory.id);

$payload = [
    "content" => "User prefers terse technical answers and works in TypeScript.",
    "metadata" => [
        "userId" => "user:4269",
        "source" => "onboarding",
    ],
];

$ch = curl_init("https://fuses.ai/api/memory");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "Authorization: Bearer YOUR_API_KEY",
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
]);

$memory = json_decode(curl_exec($ch), true);

echo $memory["id"];

import requests

response = requests.post(
    "https://fuses.ai/api/memory",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "content": "User prefers terse technical answers and works in TypeScript.",
        "metadata": {"userId": "user:4269", "source": "onboarding"},
    },
)

memory = response.json()
print(memory["id"])

require "net/http"
require "json"

uri = URI("https://fuses.ai/api/memory")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer YOUR_API_KEY"
request.body = {
  content: "User prefers terse technical answers and works in TypeScript.",
  metadata: { userId: "user:4269", source: "onboarding" }
}.to_json

response = http.request(request)
memory = JSON.parse(response.body)

puts memory["id"]

const response = await fetch("https://fuses.ai/api/memory", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer YOUR_API_KEY",
  },
  body: JSON.stringify({
    content: "User prefers terse technical answers and works in TypeScript.",
    metadata: {
      userId: "user:4269",
      source: "onboarding",
    },
  }),
});

const memory = await response.json();

console.log(memory.id);

Request params

Field	Type	Description
id	string	Optional memory id. If passed, it appends to the existing memory, otherwise creates a new memory.
content	string	Required context to store or append.
metadata	object	Optional caller-owned labels such as `user id`, `source`, `account id`, or `workflow id`. On append, any keys included overwrite values set on earlier writes.

Sample response

The response includes the generated memory id that should be reused for later appends and reads.

{
  "id": "A7K9P2QX4M",
  "status": "created",
  "createdAt": "2026-05-02T16:00:00.000Z",
  "usage": {
    "bytes": 67,
    "tokens": 13
  }
}

Append to memory

Append content to an existing memory.

POST`/api/memory`

curl https://fuses.ai/api/memory \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "id": "A7K9P2QX4M",
    "content": "User is evaluating hosted vector databases for a B2B SaaS product.",
    "metadata": {
      "source": "chat"
    }
  }'

const response = await fetch("https://fuses.ai/api/memory", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer YOUR_API_KEY",
  },
  body: JSON.stringify({
    id: "A7K9P2QX4M",
    content: "User is evaluating hosted vector databases for a B2B SaaS product.",
    metadata: {
      source: "chat",
    },
  }),
});

const memory = await response.json();

console.log(memory.status);

$payload = [
    "id" => "A7K9P2QX4M",
    "content" => "User is evaluating hosted vector databases for a B2B SaaS product.",
    "metadata" => [
        "source" => "chat",
    ],
];

$ch = curl_init("https://fuses.ai/api/memory");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "Authorization: Bearer YOUR_API_KEY",
    ],
    CURLOPT_POSTFIELDS => json_encode($payload),
]);

$memory = json_decode(curl_exec($ch), true);

echo $memory["status"];

import requests

response = requests.post(
    "https://fuses.ai/api/memory",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "id": "A7K9P2QX4M",
        "content": "User is evaluating hosted vector databases for a B2B SaaS product.",
        "metadata": {"source": "chat"},
    },
)

memory = response.json()
print(memory["status"])

require "net/http"
require "json"

uri = URI("https://fuses.ai/api/memory")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer YOUR_API_KEY"
request.body = {
  id: "A7K9P2QX4M",
  content: "User is evaluating hosted vector databases for a B2B SaaS product.",
  metadata: { source: "chat" }
}.to_json

response = http.request(request)
memory = JSON.parse(response.body)

puts memory["status"]

const response = await fetch("https://fuses.ai/api/memory", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: "Bearer YOUR_API_KEY",
  },
  body: JSON.stringify({
    id: "A7K9P2QX4M",
    content: "User is evaluating hosted vector databases for a B2B SaaS product.",
    metadata: {
      source: "chat",
    },
  }),
});

const memory = await response.json();

console.log(memory.status);

Sample response — Append to memory

{
  "id": "A7K9P2QX4M",
  "status": "appended",
  "updatedAt": "2026-05-02T16:04:12.000Z",
  "usage": {
    "bytes": 142,
    "tokens": 29
  }
}

Retrieve a memory

Fetch the stored memory given a memory ID. Returns the accumulated content and current caller-owned metadata.

GET`/api/memory/:id`

curl https://fuses.ai/api/memory/A7K9P2QX4M \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch("https://fuses.ai/api/memory/A7K9P2QX4M", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const memory = await response.json();

console.log(memory.content);

$ch = curl_init("https://fuses.ai/api/memory/A7K9P2QX4M");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOUR_API_KEY",
    ],
]);

$memory = json_decode(curl_exec($ch), true);

echo $memory["content"];

import requests

response = requests.get(
    "https://fuses.ai/api/memory/A7K9P2QX4M",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)

memory = response.json()
print(memory["content"])

require "net/http"
require "json"

uri = URI("https://fuses.ai/api/memory/A7K9P2QX4M")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"

response = http.request(request)
memory = JSON.parse(response.body)

puts memory["content"]

const response = await fetch("https://fuses.ai/api/memory/A7K9P2QX4M", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const memory = await response.json();

console.log(memory.content);

Sample response

{
  "id": "A7K9P2QX4M",
  "content": "User prefers terse technical answers and works in TypeScript.\n\nUser is evaluating hosted vector databases for a B2B SaaS product.",
  "metadata": {
    "userId": "user:4269",
    "source": "chat"
  },
  "createdAt": "2026-05-02T16:00:00.000Z",
  "updatedAt": "2026-05-02T16:04:12.000Z"
}

Fetch summary

Returns a summary of the memory content.

curl https://fuses.ai/api/memory/A7K9P2QX4M/summary \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch("https://fuses.ai/api/memory/A7K9P2QX4M/summary", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const summary = await response.json();

console.log(summary.summary);

$ch = curl_init("https://fuses.ai/api/memory/A7K9P2QX4M/summary");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOUR_API_KEY",
    ],
]);

$summary = json_decode(curl_exec($ch), true);

echo $summary["summary"];

import requests

response = requests.get(
    "https://fuses.ai/api/memory/A7K9P2QX4M/summary",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)

summary = response.json()
print(summary["summary"])

require "net/http"
require "json"

uri = URI("https://fuses.ai/api/memory/A7K9P2QX4M/summary")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"

response = http.request(request)
summary = JSON.parse(response.body)

puts summary["summary"]

const response = await fetch("https://fuses.ai/api/memory/A7K9P2QX4M/summary", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const summary = await response.json();

console.log(summary.summary);

Summary response

{
  "id": "A7K9P2QX4M",
  "summary": "The user works in TypeScript, prefers terse technical answers, and is evaluating hosted vector databases for a B2B SaaS product.",
  "usage": {
    "inputTokens": 311,
    "outputTokens": 32
  },
  "updatedAt": "2026-05-02T16:04:12.000Z"
}

Fetch metadata

Fetch metadata when you need labels, usage details, or storage information without loading the full memory.

curl https://fuses.ai/api/memory/A7K9P2QX4M/metadata \
  -H "Authorization: Bearer YOUR_API_KEY"

const response = await fetch("https://fuses.ai/api/memory/A7K9P2QX4M/metadata", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const metadata = await response.json();

console.log(metadata.usage.tokens);

$ch = curl_init("https://fuses.ai/api/memory/A7K9P2QX4M/metadata");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer YOUR_API_KEY",
    ],
]);

$metadata = json_decode(curl_exec($ch), true);

echo $metadata["usage"]["tokens"];

import requests

response = requests.get(
    "https://fuses.ai/api/memory/A7K9P2QX4M/metadata",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
)

metadata = response.json()
print(metadata["usage"]["tokens"])

require "net/http"
require "json"

uri = URI("https://fuses.ai/api/memory/A7K9P2QX4M/metadata")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer YOUR_API_KEY"

response = http.request(request)
metadata = JSON.parse(response.body)

puts metadata["usage"]["tokens"]

const response = await fetch("https://fuses.ai/api/memory/A7K9P2QX4M/metadata", {
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
  },
});

const metadata = await response.json();

console.log(metadata.usage.tokens);

Metadata response

Returns full metadata fields for the memory.

{
  "id": "A7K9P2QX4M",
  "metadata": {
    "source": "onboarding",
    "userId": "user:4269"
  },
  "usage": {
    "bytes": 142,
    "tokens": 29
  },
  "createdAt": "2026-05-02T16:00:00.000Z",
  "updatedAt": "2026-05-02T16:04:12.000Z"
}

Home AI Models API Privacy Terms Feedback

fuses.ai

Fuses API

One Integration

Low Latency & Scale

Summary + Data

Endpoints

Query multiple models & summarize outputs

POST/api/query

Request params

Query multiple models — Sample response

Sample Streaming request — Query multiple models

Streaming response

List available models

GET/api/models

Sample response

Create a new memory

POST/api/memory

Request params

Sample response

Append to memory

POST/api/memory

Sample response — Append to memory

Retrieve a memory

GET/api/memory/:id

Sample response

Fetch summary

Summary response

Fetch metadata

Metadata response

POST`/api/query`

GET`/api/models`

POST`/api/memory`

POST`/api/memory`

GET`/api/memory/:id`