A High Speed API to Detect Low Substance Text

A lightweight, transformer-based API that evaluates text for substance, depth, and clarity in under 25ms while achieving 87% of the accuracy of a full-scale LLM.

Live Demo

Quick Test:
Substance Score
0.00

Bluesky Feed

The Substance API was developed and tested using the Bluesky firehose to ensure that it can handle high volume, unstructured, real-world data. It acts as the core structural engine alongside standard regex and toxicity pre-filters. The live feed samples the Bluesky firehose in real time and returns posts that have a substance rating of 0.70 or above.

View the Bluesky Feed
Low Substance 0.26
"bruh wtf idk why but the thing is lowkey doing that weird thing again pls fix it asap fr fr lol smh i’m literally crying rn"
Moderate Substance 0.46
"I tried setting up the new router this morning but the admin panel keeps timing out. Has anyone else seen this?"
High Substance 0.76
"Achilles’ wrath, to Greece the direful spring/Of woes unnumbered, heavenly goddess, sing!"

Applications & Use Cases

The Substance API is a fast and inexpensive pre-screening tool designed to integrate with your existing classification pipeline. It is specifically designed for high-volume, automated data pipelines.

Machine Facing Applications
Protect your downstream compute. Intercept unstructured data before it costs you money to process, embed, or infer.

RAG Pipelines & Retrieval

Stop paying tokens for noise. Pre-filter scraped pages and document chunks, dropping menus, boilerplate, and stub text before it reaches your embedding model.

Agent Memory Filtering

Keep autonomous agent scratchpads clean. Filter tool outputs and intermediate web scrapes so the LLM only retains dense facts, preventing context window bloat.

Prompt Gating

Reject low-context user prompts (like "fix my code") before triggering expensive LLM inferences, forcing users to provide useful detail first.

Dataset Curation

Rank and filter large text collections without paying for LLM-as-a-judge. Build fine-tuning sets by keeping high-substance text and dropping filler in batch.

Web Scraping & Crawling

Drop SEO filler, navigation menus, and repetitive boilerplate from raw HTML scrapes before they ever enter your data ingestion pipelines.

Vector Database Pruning

Scan existing vector databases and identify low-substance embeddings for removal, immediately improving search accuracy and reducing cloud storage costs.



Human Facing Applications
Protect people's time. Intercept low-effort noise before it reaches an inbox, a dashboard, or a community feed.

CRM & Support Tickets

Score support tickets and bug reports before a human opens them. Auto-request missing details from vague one-liners and prioritize actionable messages.

User Feedback & Reviews

Separate real signal from "great app" and "it's broken." Score survey responses and route reproducible feedback to Jira, keeping generic noise away from product managers.

Online Forums & Communities

Surface the most substantive answers in communities and social feeds. Automatically bury reactive, low-effort noise to elevate high-quality, thoughtful discussions.

Live Input Coaching

Catch thin submissions at the source. Add IndieML to forms and bug reporters to prompt people for what's missing while they're still typing.

Email & Message Triage

Score inbound lead forms and public-facing email addresses. Flag dense, high-value inquiries for immediate attention while routing empty corporate filler to the archive.

Form & Application Intake

Score grant proposals, vendor requests, or job applications upon submission to ensure human evaluators only spend time reading substantive, high-effort documents.

Methodology & Architecture

Knowledge Distillation

The training process distills the semantic reasoning of frontier LLMs into a lightweight, high-throughput encoder. Using a dataset specifically labeled to evaluate structural complexity and semantic weight, the Substance model achieves an 87% correlation with its LLM teachers—which themselves demonstrate a 95% correlation with human-labeled data. This allows the API to retain high accuracy while operating at a fraction of the latency of an LLM.

High-Throughput Inference Engine

The API is built on an asynchronous FastAPI architecture to handle high volumes of concurrent requests without bottlenecks. By utilizing an INT8-quantized encoder and executing the ONNX graph directly in-memory, the server delivers stable real-time inference with a baseline latency of ~25ms. For data privacy, all user text is evaluated entirely in volatile memory and is never logged or stored.

Plans & Pricing

Start for free, scale as required. No hidden fees.

Free

$0 / mo
  • Up to 10,000 requests / month
  • No rate limiting
Get API Key

Starter

$19 / mo
Free During Developer Preview
  • Up to 100,000 requests / month
  • No rate limiting
Request Starter Tier

Growth

$49 / mo
Free During Developer Preview
  • Up to 500,000 requests / month*
  • No rate limiting
  • * Includes 100,000 base + $0.0001 per additional request
Request Growth Tier

Enterprise

Custom
  • 500,000+ requests / month
  • No rate limiting
  • Custom SLA, volume discounts
Request Enterprise Tier

Integration

Connect to the API via standard REST requests, our native Python SDK, or drop-in MCP configurations for AI agents.

curl -X POST https://indieml.app/v1/score/substance \
  -H "X-API-KEY: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input_text": "This is a test run."
  }'
import requests

url = "https://indieml.app/v1/score/substance"
headers = {
    "X-API-KEY": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "input_text": "This is a test run."
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())
const response = await fetch('https://indieml.app/v1/score/substance', {
  method: 'POST',
  headers: {
    'X-API-KEY': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    input_text: "This is a test run."
  })
});
console.log(await response.json());
curl -X POST https://indieml.app/v1/score/substance/batch \
  -H "X-API-KEY: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input_texts": ["This is a test run.", "This is another test run."]
  }'
import requests

url = "https://indieml.app/v1/score/substance/batch"
headers = {
    "X-API-KEY": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "input_texts": ["This is a test run.", "This is another test run."]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())
const response = await fetch('https://indieml.app/v1/score/substance/batch', {
  method: 'POST',
  headers: {
    'X-API-KEY': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    input_texts: ["This is a test run.", "This is another test run."]
  })
});
console.log(await response.json());
# Install via terminal: pip install indieml

from indieml import Substance

# Initialize the API
api = Substance(api_key="YOUR_API_KEY_HERE")

# Single string
single_result = api.score("This is a test run.")
print(single_result)

# Array of strings
batch_result = api.score_batch([
    "This is a test run.", 
    "This is another test run."
])
print(batch_result)
// Install via terminal: npm install indieml

// Import based on your environment
import { IndieML } from 'indieml';  // for ES Modules / TypeScript or
const { IndieML } = require('indieml');  // for CommonJS

// Initialize the API
const api = new IndieML({ apiKey: "YOUR_API_KEY_HERE" });

// Single string
const singleResult = await api.score("This is a test run.");
console.log(singleResult);

// Array of strings
const batchResult = await api.scoreBatch([
    "This is a test run.",
    "This is another test run."
]);
console.log(batchResult);
// Streamable HTTP (Cursor, ChatGPT, Claude Code)
{
  "mcpServers": {
    "indieml": {
      "type": "http",
      "url": "https://indieml.app/mcp/",
      "headers": {
        "X-API-Key": "YOUR_API_KEY_HERE"
      }
    }
  }
}
// stdio via npx Bridge (Requires Node.js v20+)
{
  "mcpServers": {
    "indieml": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://indieml.app/mcp/",
        "--header",
        "X-API-Key:${INDIEML_API_KEY}"
      ],
      "env": {
        "INDIEML_API_KEY": "YOUR_API_KEY_HERE"
      }
    }
  }
}
Response (200 OK)
{
  "result": {
    "text": "This is a test run.",
    "substance_score": 0.18
  }
}
{
  "results": [
    {
      "text": "This is a test run.",
      "substance_score": 0.16
    },
    {
      "text": "This is another test run.",
      "substance_score": 0.20
    }
  ]
}
// Output from single result
{
  "text": "This is a test run.",
  "substance_score": 0.18
}

// Output from batch result - scores can differ slightly due to input data padding
[
  {
    "text": "This is a test run.",
    "substance_score": 0.16
  },
  {
    "text": "This is another test run.",
    "substance_score": 0.20
  }
]

You can also integrate IndieML directly into your CRM pipeline.

Salesforce Integration Guide Zendesk Integration Guide

Start building for free

Enter your email to get a free API key. No credit card required.