API Access & Environments

Inherent exposes two entry points: a Public API for programmatic access and a Dashboard for account management. They run on separate subdomains, use different auth mechanisms, and serve different purposes.

Two Entry Points

Public API

Production	https://api.inherent.systems
Development	https://dev-api.inherent.systems
Auth	API key via X-API-Key header (keys prefixed ink_)
Purpose	Programmatic access for AI applications

This is what you integrate with. The Public API lets you upload documents, run semantic searches, retrieve chunks, and build context windows for your AI systems.

Available endpoints:

Method	Path	Description
POST	/api/v1/documents	Upload a document
GET	/api/v1/documents	List documents
GET	/api/v1/documents/:id	Get document details
POST	/api/v1/search	Semantic search across your workspace
GET	/api/v1/chunks/:document_id	Get chunks for a document
GET	/api/v1/chunks/:document_id/context	Get contextual chunks
GET	/api/v1/health	Health check

Dashboard

Production	https://app.inherent.systems
Development	https://dev.inherent.systems
Auth	Email/password via Clerk
Purpose	Web UI for account management

The Dashboard is not an API you integrate with. Use it to:

• Create and manage workspaces
• Generate and revoke API keys
• Upload and browse documents
• Monitor ingestion status
• Manage billing and subscription

Environment URLs

Environment	Public API	Dashboard
Production	https://api.inherent.systems	https://app.inherent.systems
Development	https://dev-api.inherent.systems	https://dev.inherent.systems

tip

Use the development environment for testing and integration work. It shares the same API surface but runs against a separate database.

How It Works Under the Hood

                    +--------------------------+
                    |     Nginx Reverse Proxy   |
                    |   (routes by subdomain)   |
                    +------+----------+--------+
                           |          |
            +--------------+--+  +----+--------------+
            | api.inherent.*  |  | app.inherent.*    |
            |                 |  |                    |
            | Public API      |  | Dashboard          |
            | (FastAPI/Python)|  | (Next.js + Express)|
            +---------+-------+  +-------+------------+
                      |                  |
                      +--------+---------+
                               |
                    +----------+-----------+
                    |                      |
              +-----+------+     +--------+--------+
              | PostgreSQL  |     |    Weaviate     |
              | (documents, |     | (embeddings,    |
              |  chunks)    |     |  search index)  |
              +-------------+     +-----------------+

• The Public API is a dedicated Python/FastAPI service (inh-public-api-svc) exposed on its own subdomain. This is the only service developers should call programmatically.
• The Dashboard is a Next.js app backed by an Express.js API service (inh-intg-svc). The Express backend is not directly accessible as a public API -- it only serves the Dashboard UI.
• Both services read from the same PostgreSQL (documents, chunks) and Weaviate (embeddings, search) databases, so data is consistent across both interfaces.
• Nginx routes requests by subdomain: api.* goes to the Public API, app.* / dev.* goes to the Dashboard.

Getting Started

1. Sign up at the Dashboard
2. Create a workspace -- this scopes all your documents and searches
3. Generate an API key -- go to Settings > API Keys and create a key
4. Start calling the API:

curl https://api.inherent.systems/api/v1/documents \
  -H "X-API-Key: ink_your_api_key_here"

info

API keys are scoped to a single workspace. If you have multiple workspaces, you'll need a separate key for each.

Next Steps

• API Overview -- full endpoint reference
• Python SDK -- Python wrapper (or use requests directly)
• TypeScript SDK -- TypeScript wrapper (or use fetch directly)
• Quickstart -- end-to-end tutorial