# What Kind of Data Does OmniRoute Process? A Complete Guide to AI Proxy Data Types

> OmniRoute processes diverse AI proxy data from chat completions to image generation, plus internal data like PII masking. Discover all supported data types in this guide.

- Repository: [Diego Rodrigues de Sa e Souza/OmniRoute](https://github.com/diegosouzapw/OmniRoute)
- Tags: deep-dive
- Published: 2026-07-16

---

**OmniRoute processes chat completions, embeddings, image/audio/video/music generation, search queries, file uploads, and batch operations through OpenAI-compatible API endpoints, while also handling internal data like PII masking, memory context, and compression plans.**

OmniRoute is a universal AI proxy built on Next.js that accepts diverse request payloads and returns unified responses. Understanding what kind of data OmniRoute processes is essential for developers integrating with its routing layer, as the platform normalizes inputs from dozens of providers into a consistent OpenAI-style interface. This guide examines the core data types, file formats, and internal processing pipelines implemented in the `diegosouzapw/OmniRoute` repository.

## Core AI Data Types

OmniRoute exposes standard AI workloads through RESTful endpoints in `src/app/api/v1/`, each validating inputs with Zod schemas before translation.

### Chat Completions and Text Generation

The primary data type processed by OmniRoute is **chat completion requests**, which include a `model` identifier and a `messages` array containing role-based content (user, assistant, system). Optional parameters like `stream`, `temperature`, and `max_tokens` control response behavior. When a streaming request arrives at [`src/app/api/v1/chat/completions/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/chat/completions/route.ts), the system extracts custom headers such as `X-OmniRoute-No-Cache` and `X-Session-Id` before forwarding the payload through the translator pipeline.

### Embeddings and Vector Search

**Embedding requests** accept a `model` string and an `input` field containing plain text to be vectorized. As implemented in [`src/app/api/v1/embeddings/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/embeddings/route.ts), these payloads are transformed by [`open-sse/translator/index.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/translator/index.ts) to match provider-specific formats, whether processing via Nebius, OpenAI, or other supported backends.

### Image, Video, and Audio Generation

Multimedia generation endpoints handle binary and text inputs:

- **Image generation**: `POST /v1/images/generations` accepts `model`, `prompt`, and optional `size`, `quality`, and `style` parameters (see [`src/app/api/v1/images/generations/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/images/generations/route.ts))
- **Video generation**: `POST /v1/videos/generations` processes `model`, `prompt`, and optional `resolution` or `duration` values
- **Audio transcription**: `POST /v1/audio/transcriptions` receives binary audio files with optional `language` hints
- **Text-to-speech**: `POST /v1/audio/speech` converts text inputs to audio using voice parameters

These routes reside in [`src/app/api/v1/videos/generations/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/videos/generations/route.ts), [`src/app/api/v1/audio/transcriptions/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/audio/transcriptions/route.ts), and [`src/app/api/v1/audio/speech/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/audio/speech/route.ts) respectively.

## Utility and Administrative Data

Beyond generative AI, OmniRoute processes operational data types for file management, bulk operations, and information retrieval.

### File Uploads and Binary Data

The **Files API** at [`src/app/api/v1/files/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/files/route.ts) handles binary uploads with metadata attachments, supporting `POST /v1/files` for creation and `GET /v1/files/{id}` for retrieval. This enables workflows that require document analysis or persistent storage across sessions.

### Batch Operations and Bulk Processing

**Batch requests** allow multiple operations in a single call to `POST /v1/batches`. The payload contains an array of request objects, each specifying a method, path, and body—enabling mixed workloads like combining chat completions with embeddings in one transaction. This logic is implemented in [`src/app/api/v1/batches/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/batches/route.ts).

### Search and Reranking

OmniRoute processes **search queries** via `POST /v1/search`, accepting `model` and `query` parameters with optional filters, and **reranking** requests at `POST /v1/rerank` that include `model`, `query`, and `documents` arrays. These endpoints leverage the built-in web-search provider and semantic reranking capabilities as defined in [`src/app/api/v1/search/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/search/route.ts) and [`src/app/api/v1/rerank/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/rerank/route.ts).

## Internal System Data

The proxy layer handles specialized data types for security, memory, and protocol compatibility.

### Guardrails and PII Masking

Before upstream transmission, requests pass through **guardrail modules** that examine raw bodies for sensitive data. The `src/lib/guardrails/pii‑masker.ts` implementation can redact personally identifiable information based on configurable rules, processing the same JSON payloads that eventually reach AI providers.

### Memory and Skills Injection

OmniRoute injects **structured context snippets** via `src/lib/memory/` and **skill-specific inputs** through `src/lib/skills/`. These data types aren't exposed directly to API clients but are merged into prompts during the execution phase, enabling persistent conversation memory and tool-use capabilities.

### A2A and MCP Protocol Data

The system supports **Agent-to-Agent (A2A)** protocols using JSON-RPC 2.0 request/response objects handled in `src/lib/a2a/`, and **Model Context Protocol (MCP)** tool definitions managed in `open-sse/mcp-server/`. These endpoints process event payloads and tool-specific JSON schemas that enable autonomous agent workflows.

## Processing Pipeline: How OmniRoute Handles Data

According to the OmniRoute source code, the request flow transforms incoming data through six distinct stages:

1. **API Route validation**: Next.js routes in `src/app/api/v1/*` receive HTTP requests and validate payloads against Zod schemas
2. **Translation**: [`open-sse/translator/index.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/translator/index.ts) converts OpenAI-style requests into provider-specific formats
3. **Execution**: Provider-specific executors in `open-sse/executors/` construct upstream URLs, headers, and bodies
4. **Combo routing**: When active, [`open-sse/services/combo.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/services/combo.ts) dispatches requests to multiple providers sequentially or in parallel
5. **Response transformation**: Upstream responses are normalized back to OpenAI-compatible formats with enriched headers
6. **Guardrails and compression**: Optional modules in `src/lib/guardrails/` and [`open-sse/compression/lite.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/compression/lite.ts) may redact PII or condense prompts based on `X-OmniRoute-Compression` header values

## Code Examples

### Streaming Chat Completion

```http
POST /v1/chat/completions
Authorization: Bearer sk-********
Content-Type: application/json
X-OmniRoute-Compression: default

{
  "model": "cc/claude-opus-4-6",
  "messages": [{ "role": "user", "content": "Explain quantum tunneling." }],
  "stream": true
}

```

### Embedding Request

```http
POST /v1/embeddings
Authorization: Bearer sk-********
Content-Type: application/json

{
  "model": "nebius/Qwen/Qwen3-Embedding-8B",
  "input": "The food was delicious"
}

```

### Image Generation

```http
POST /v1/images/generations
Authorization: Bearer sk-********
Content-Type: application/json

{
  "model": "openai/gpt-image-2",
  "prompt": "A beautiful sunset over mountains",
  "size": "1024x1024"
}

```

### Mixed Batch Request

```http
POST /v1/batches
Authorization: Bearer sk-********
Content-Type: application/json

{
  "requests": [
    {
      "method": "POST",
      "path": "/v1/chat/completions",
      "body": {
        "model": "openai/gpt-4o",
        "messages": [{ "role": "user", "content": "Who won the 2024 Olympics?" }]
      }
    },
    {
      "method": "POST",
      "path": "/v1/embeddings",
      "body": {
        "model": "openai/text-embedding-3-large",
        "input": "Machine learning is evolving."
      }
    }
  ]
}

```

## Summary

- **OmniRoute processes text, embeddings, multimedia (images, video, audio), and binary files** through standardized OpenAI-compatible endpoints
- **Utility operations** include search queries, reranking, file uploads, and batch processing of mixed request types
- **Internal data handling** encompasses PII masking via `src/lib/guardrails/pii‑masker.ts`, memory injection from `src/lib/memory/`, and compression plans controlled by `X-OmniRoute-Compression` headers
- **Protocol support** extends to A2A JSON-RPC and MCP tool schemas for agent-based workflows
- **Request flow** moves from Next.js API routes through translators and executors in `open-sse/`, with optional combo routing and guardrail processing

## Frequently Asked Questions

### What format does OmniRoute expect for chat completion requests?

OmniRoute expects standard OpenAI-compatible JSON payloads with a `model` field and a `messages` array containing objects with `role` and `content` properties. The system accepts optional parameters like `stream`, `temperature`, and `max_tokens`, validating these inputs in [`src/app/api/v1/chat/completions/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/chat/completions/route.ts) before translation to provider-specific formats.

### Does OmniRoute support batch processing of different data types?

Yes, the `POST /v1/batches` endpoint accepts an array of request objects, each specifying a method, path, and body. This allows mixing chat completions, embeddings, and other operations in a single request, processed sequentially by the handler in [`src/app/api/v1/batches/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/batches/route.ts).

### How does OmniRoute handle sensitive data like PII?

Before upstream transmission, requests may pass through guardrail modules in `src/lib/guardrails/` that examine raw request and response bodies for sensitive information. The `pii‑masker.ts` implementation can redact identifiable data based on configurable security rules, ensuring compliant handling of personal information.

### Can OmniRoute process binary files like audio and images?

Yes, OmniRoute handles binary data through dedicated endpoints. Audio files are processed via `POST /v1/audio/transcriptions` in [`src/app/api/v1/audio/transcriptions/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/audio/transcriptions/route.ts), while general file uploads use `POST /v1/files` with binary payloads and metadata attachments, managed by [`src/app/api/v1/files/route.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/app/api/v1/files/route.ts).