Privacy Policy

Effective Date: March 7, 2026

We never use your files or data in any way, except to process your request. Period.

File Storage

The files you submit are stored locally for the duration of your visit to the site, plus fifteen minutes. File contents are never retained, nor are they ever shared with any third party.

Logging

We log your email address, the types of conversions you did, incidental file metadata, and timestamp information for performance monitoring and abuse prevention purposes. Logs are retained for 90 days. Logs are never shared with any third party.

Free Use

No user information beyond originating IP address and file metadata is retained for users of the free service. No credit card or email information is required to use the free service.

Rate-Limiting

We reserve the right to rate-limit requests from IP address that appear to be abusing or attacking the service.

Subscriptions and Keys

All payments are processed by Stripe. We never see nor have access to your credit card information, Stripe simply informs us that your payment was valid.

Information Sharing

Absolutely none of your information ever leaves this site. No logs, no file metadata, no email addresses, no file contents. Your data resides on our servers for the duration of your visit plus fifteen minutes, and is deleted permanently.

Data Security

We protect user data with standard industry best-practices to prevent unauthorized information collection and disclosure.

Contact Information

There is a contact/feedback form on the Contacts page. We encourage you to reach out if you have questions, concerns, or suggestions. We read every message.

Security

We protect user data with standard industry best-practices to prevent unauthorized information collection and disclosure.

Security Policy

This page will always contain our current security information, with a date at the top for the last time it was updated.

Pricing

No account required to try. Convert up to 100 rows free. Register for more.

Subscriptions renew monthly. Cancel anytime — access continues through the paid period. All prices in USD.

Docs

Upload a file, preview it, transform it, and download it in any supported format. Files are processed in memory and never stored.

CLI (alpha)

Professional subscribers can also use Reparatio from the command line without writing raw HTTP calls.

pipx install reparatio-cli
reparatio key set rp_YOUR_KEY
reparatio convert sales.csv sales.parquet
reparatio inspect report.xlsx

In early alpha — interfaces may change. Requires a Professional subscription API key.

Supported Formats

Gzip (.csv.gz, .tsv.gz, etc.), bzip2 (.csv.bz2, etc.), Zstandard (.csv.zst, etc.), and ZIP archives are decompressed automatically on input — the first file inside a ZIP is used. Hive-partitioned Parquet: upload a ZIP containing only .parquet files to load them as a single merged dataset; partition columns are automatically extracted from key=value directory names (e.g. year=2024/region=west/data.parquet).

Convert

The main tab. Upload a file, preview the schema and first 8 rows, then download in any output format.

• Fix Encoding — Auto-detects character encoding and repairs garbled text (mojibake). Recommended for files from legacy systems. On by default. Includes an EBCDIC heuristic that detects common mainframe encodings automatically. For reliable results with EBCDIC files, use the API's encoding_override parameter (e.g. cp037 for EBCDIC US, cp500 for EBCDIC International, cp1026 for EBCDIC Turkish, cp1140 for EBCDIC US with Euro sign) via the CLI, SDK, or MCP server.
• No header row — For CSV/TSV files where the first row is data. Columns will be named col_0, col_1, etc.
• Make headers editable — Click any column header in the preview to rename it. The new names are used in the output.
• Delimiter — For CSV-like files with a non-standard separator (e.g. | or ;). Leave blank to auto-detect.
• Sheet / Table picker — Appears automatically for formats with multiple tables: Excel, ODS, SQLite, HTML, SQL dumps, PDF, and Markdown files.
• Column selection — Check or uncheck columns to include in the output. Use Toggle All to flip all at once. Hover a column header to see its type, null count, and unique count.
• Schema export — After previewing a file, a collapsible Schema export panel appears below the preview. It shows the detected schema as a ready-to-paste Polars schema= dict, a Pandas dtype= dict, and a CREATE TABLE SQL statement. Each block has a copy button.
• Override column types — After previewing, expand Override column types inside the column selector to change how a column is interpreted at conversion time. Select the target type from the dropdown; for Date or Datetime columns, an optional format field appears (e.g. %d/%m/%Y). Unsupported values are silently coerced to null rather than aborting the conversion.
• Null value strings — Enter a comma-separated list of strings to treat as null when loading the file (e.g. N/A, NULL, -, none). Passed as Polars null_values=. Useful for files where missing data is encoded as a placeholder rather than an empty cell.
• Column reordering — Use the up/down arrow buttons in the column selection table to reorder columns before converting. The output file respects the new column order.
• Filter rows — Enter a SQL WHERE-style expression to keep only matching rows. No SQL keyword needed — just the condition, e.g. amount > 100 and region = 'EU'. Column names are case-sensitive.
• Deduplicate rows — Removes duplicate rows from the output, keeping the first occurrence.
• Sample — Output a random sample. Enter a number of rows (e.g. 1000) or a fraction (e.g. 0.1 for 10%). Only one is applied; row count takes priority if both are set.
• Preview Output — Click the Preview Output button to see the first 8 rows of the converted file before downloading. Calls /convert with preview_only=true and renders the result as a table. No credit is consumed for previews.

Merge

Combine two or more files into one. Select both files — shared columns are detected automatically for join operations.

• Append — Stack all rows from both files vertically. Columns that don't exist in one file are filled with null. You can add additional files beyond the first two using the "+ Add another file" button.
• Left Join — All rows from File 1; matching columns from File 2 where the join column(s) match.
• Right Join — All rows from File 2; matching columns from File 1 where the join column(s) match.
• Full Outer Join — All rows from both files; nulls where no match exists.
• Inner Join — Only rows where the join column(s) match in both files.

Use Preview Result to inspect the first 8 rows before downloading. A warning is shown if columns are mismatched on append.

Append

Stack rows from two or more files into a single output. Available as a dedicated tab in the web UI (between Merge and SQL). Columns are matched by name; columns missing from some files are filled with null.

• Upload two or more files and choose an output format. The files are concatenated in the order they were added.
• A warning is shown if column sets differ between files.
• Also available via the API at /api/v1/append, the CLI (reparatio append), and the Python SDK (client.append()).

SQL Query

Run a SQL query directly against an uploaded file. The file is loaded as a table named data.

• Standard SQL is supported: SELECT, WHERE, GROUP BY, ORDER BY, LIMIT, aggregations, and most scalar functions.
• Use Preview Result to run the query and see the first 8 rows as a table.
• Use Download Result to run the query and save the full output in your chosen format.
• For Excel, ODS, SQLite, HTML, SQL dumps, and other multi-table formats, a sheet picker appears after selecting the file.
• File caching — your file is uploaded once and held in memory on the server for 15 minutes. Every query you run against it resets the clock. You can run as many queries as you like without re-uploading. If the session expires after 15 minutes of inactivity, the file is automatically re-uploaded on your next query.

JSON Flattener

Available for all users; unlimited nesting depth requires a Standard or Professional subscription. After previewing a .json or .jsonl file, a Flatten nested JSON checkbox appears in the options row. When checked, nested objects are expanded into flat columns using _ as a separator (e.g. address_city).

• Depth — Controls how many levels of nesting to expand. 1 level expands only top-level keys. Unlimited recurses all the way down; requires Standard or Professional. Free users who select Unlimited receive 1-level flattening in the downloaded file (the preview is unrestricted).
• Arrays: Serialize as JSON strings — Any column that still contains a list after normalization is converted to a JSON string (e.g. ["a","b"]). This is the safe default — no rows are added or lost.
• Arrays: Explode first array column — The first column that contains lists is exploded: each list element becomes its own row. Useful when the array represents repeated records (e.g. a tags or items field). Remaining list columns are serialized as JSON strings.
• For .json files without the checkbox checked, the existing behaviour is preserved: one level of normalization is applied automatically.
• For .jsonl files without the checkbox, each line is read as a native Polars row, preserving Struct and List column types.

Data Cleaner

Standard or Professional subscribers only. After previewing a file on the Convert tab, a Clean This File button appears below the preview. Click it to apply the selected cleaning operations in one step. The preview updates immediately and the download button uses the cleaned data.

• Remove duplicate rows — Keeps the first occurrence of each duplicate row and discards the rest.
• Drop empty columns — Removes any column whose every value is null or blank.
• Fix placeholders — Converts common stand-ins for missing data (N/A, NULL, null, None, -, nan, missing, etc.) to proper null values.
• Strip whitespace — Removes leading and trailing spaces from every string cell.
• Standardize numbers — Strips currency symbols and thousands separators from string columns that look mostly numeric (e.g. $1,234.56 → 1234.56). Only applied to columns where more than 50 % of non-null values parse as a number. Unchecked by default.
• Missing values — Choose whether to keep nulls as-is, drop any row that contains a null, or replace null strings with an empty string.

After cleaning, a summary is shown: e.g. "Removed 2,347 duplicate rows · Dropped 3 empty columns · Fixed 45 placeholders." The cleaned file is held in the 15-minute cache; use Download Converted File to save it in your chosen format.

File Splitter

Standard or Professional subscribers only. Upload a large file and split it into multiple smaller files, downloaded as a single ZIP archive.

• Split into N files — Divide the data into exactly N equal parts (the last part may be slightly smaller).
• Max rows per file — Each output file contains at most this many rows.
• Max size per file (MB) — Each output file is approximately this size. The row count per chunk is estimated from a 1,000-row sample of the data, so actual file sizes may vary slightly.
• Output files are named filename_part0001.ext, filename_part0002.ext, etc.
• Supported output formats: CSV, TSV, JSON Lines, Parquet, Excel (.xlsx).
• Maximum 500 output files per split operation.
• File caching is shared with the SQL Query tab — your file is held in memory for 15 minutes after upload.

Format Notes

Free Tier & Row Limits

No account or payment is required to try anything. Anonymous users get up to 100 rows per conversion and 10 conversions per day. Register and verify your email for 250 rows and 25 conversions per day — still free.

If the output exceeds the row limit and you have not entered an access key, the download will contain only the allowed rows. This applies to Convert, Merge, Append, and SQL Query alike.

To download full files without row limits, see the Pricing page.

Plans: Standard ($29/mo) for unlimited rows and all formats; Professional ($79/mo) adds API, CLI, MCP, Fixed-Width, and EBCDIC; Credits ($10 = 25 conversions) for pay-as-you-go use. Credits never expire.

Other Limits

• Maximum file size: 1 GB (combined size for Merge)
• Preview shows the first 8 rows only. The full file is used for conversion, merging, and queries.
• Excel output is limited to approximately 1,048,576 rows (Excel's row limit).
• SQLite output writes a single table named data. SQLite input reads the first table by default; use the sheet picker to choose another.

Error Messages

When something goes wrong, Reparatio shows the original technical error from the processing engine alongside a plain-English explanation. The technical message is selectable so you can copy it for a support request; the explanation beneath it describes what likely went wrong and what to try.

• Encoding errors — Enable Fix Encoding in the options. It auto-detects and repairs garbled characters from legacy systems.
• Parse errors — The file may be corrupt, or its extension may not match the actual format. Try opening it in another application first.
• Empty file / no data found — Check the sheet picker. For PDFs, the file must have a real text layer; scanned PDFs (image-only pages) cannot be read.
• SQL errors — The table is always named data. Check column names in the preview — they are case-sensitive.
• GeoJSON output fails — Your file must have a column named geometry containing WKT strings (e.g. POINT(-73.9 40.7)).

Conversion Warnings

Some conversions work well in every case. Others depend on the shape of your data.

REST API

The Reparatio REST API lets you convert, inspect, merge, query, append, and parse fixed-width and EBCDIC mainframe files programmatically. A Professional subscription is required for all endpoints that produce output files.

Base URL: https://reparatio.app/api/v1

Interactive reference (ReDoc): https://reparatio.app/api/redoc

Try-it console (Swagger UI): https://reparatio.app/api/docs

OpenAPI schema (JSON): https://reparatio.app/api/openapi.json

Higher-level wrappers (alpha)

If you prefer not to write raw HTTP calls, Reparatio provides SDKs for Python, JavaScript/TypeScript, Common Lisp, Java, and C#.

pip install reparatio

from reparatio import Reparatio
with Reparatio(api_key="rp_...") as client:
    result = client.inspect("data.csv")
    out = client.convert("data.csv", "parquet")
    open(out.filename, "wb").write(out.content)

npm install reparatio

import { Reparatio } from "reparatio";
const client = new Reparatio("rp_YOUR_KEY");

const result = await client.inspect(file, "data.csv");
const { data, filename } = await client.convert(file, "parquet", "data.csv");
const { data: zip } = await client.batchConvert(zipFile, "parquet");

; Requires SBCL + Quicklisp
(ql:quickload "reparatio")
(use-package :reparatio)
(let ((c (make-client :api-key "rp_...")))
  (inspect-file c #p"data.csv")
  (let ((r (convert c #p"data.csv" "parquet")))
    (reparatio-result-content r)))

// Requires Java 11+ (no external deps)
import com.reparatio.ReparatioClient;
var client = new ReparatioClient("rp_...");
var info   = client.inspect(Path.of("data.csv"));
var result = client.convert(Path.of("data.csv"), "parquet");
Files.write(Path.of(result.filename()), result.content());

// Requires .NET 6+ or Mono
using Reparatio;
var client = new ReparatioClient("rp_...");
var info   = await client.InspectAsync("data.csv");
var result = await client.ConvertAsync("data.csv", "parquet");
File.WriteAllBytes(result.Filename, result.Content);

# gem install reparatio
require "reparatio"
client = Reparatio.new(api_key: "rp_...")
info   = client.inspect("data.csv")
result = client.convert("data.csv", "parquet")
File.binwrite(result.filename, result.content)

Requires a Professional plan API key ($79/mo).

Authentication

Pass your API key in the X-API-Key request header. Keys are issued after purchase on the Pricing tab.

API access requires a Professional subscription. See Pricing.

X-API-Key: rp_xxxxxxxxxxxxxxxxxxxx

The /health, /formats, and /inspect endpoints do not require authentication. All other endpoints require a Professional subscription.

Common Parameters

Requests that accept a file use multipart/form-data. Parameters are form fields unless noted otherwise.

Response Headers

Error Codes

Error responses are JSON: {"detail": "human readable message"}.

Endpoints

{"status": "healthy", "version": "1"}

{"input": ["csv", "tsv", "xlsx", ...], "output": ["csv", "tsv", "parquet", ...]}

{"email": "you@example.com", "plan": "pro", "tier": "pro", "expires_at": "2026-04-14T00:00:00+00:00", "api_access": true, "active": true, "credits_balance": 0, "email_verified": true}

{
  "event":           "conversion.completed",
  "job_id":          "a3f7c2d1-84b0-4e19-9f6a-0c1d2e3f4a5b",
  "status":          "completed",
  "download_url":    "https://reparatio.app/api/v1/download/a3f7c2d1-...",
  "filename":        "sales.parquet",
  "input_format":    "csv",
  "output_format":   "parquet",
  "input_bytes":     204800,
  "output_bytes":    51200,
  "elapsed_ms":      312,
  "timestamp":       "2026-03-14T18:42:00.123456+00:00",
  "errors":          []
}

import hmac, hashlib

def verify_signature(body: bytes, header: str, secret: str) -> bool:
    expected = "sha256=" + hmac.new(
        secret.encode(), body, hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, header)

EBCDIC & Fixed-Width Format (Professional)

Reparatio can decode IBM EBCDIC mainframe files and parse fixed-width column layouts. Both features require a Professional subscription and are accessed through dedicated endpoints.

curl -X POST https://reparatio.app/api/v1/convert \
  -H "X-API-Key: rp_xxxxxxxxxxxxxxxxxxxx" \
  -F "file=@mainframe_export.dat" \
  -F "target_format=csv" \
  -F "encoding_override=cp037" \
  -o output.csv

curl -X POST https://reparatio.app/api/v1/fwf-detect \
  -H "X-API-Key: rp_xxxxxxxxxxxxxxxxxxxx" \
  -F "file=@report.txt" \
  -F "encoding_override=cp037"

curl -X POST https://reparatio.app/api/v1/fwf-convert \
  -H "X-API-Key: rp_xxxxxxxxxxxxxxxxxxxx" \
  -F "file=@report.txt" \
  -F 'boundaries=[0,10,25,40,60]' \
  -F 'col_names=["id","name","dept","salary","hire_date"]' \
  -F "target_format=parquet" \
  -F "encoding_override=cp037" \
  -o report.parquet

Code Examples

All examples convert data.csv to Parquet using the /api/v1/convert endpoint.

curl

curl -X POST https://reparatio.app/api/v1/convert \
  -H "X-API-Key: rep_live_xxxxxxxxxxxxxxxxxxxx" \
  -F "file=@data.csv" \
  -F "target_format=parquet" \
  -o data.parquet

Python

import httpx

API_KEY = "rep_live_xxxxxxxxxxxxxxxxxxxx"
BASE    = "https://reparatio.app/api/v1"

with open("data.csv", "rb") as f:
    resp = httpx.post(
        f"{BASE}/convert",
        headers={"X-API-Key": API_KEY},
        data={"target_format": "parquet"},
        files={"file": ("data.csv", f, "text/csv")},
        timeout=120,
    )
resp.raise_for_status()

with open("data.parquet", "wb") as out:
    out.write(resp.content)

print("Saved data.parquet")

JavaScript

const API_KEY = "rep_live_xxxxxxxxxxxxxxxxxxxx";
const BASE    = "https://reparatio.app/api/v1";

async function convertFile(file, targetFormat) {
  const form = new FormData();
  form.append("file", file);
  form.append("target_format", targetFormat);

  const resp = await fetch(`${BASE}/convert`, {
    method: "POST",
    headers: { "X-API-Key": API_KEY },
    body: form,
  });

  if (!resp.ok) {
    const err = await resp.json();
    throw new Error(err.detail);
  }

  const blob = await resp.blob();
  const url  = URL.createObjectURL(blob);
  const a    = document.createElement("a");
  a.href     = url;
  a.download = "data.parquet";
  a.click();
  URL.revokeObjectURL(url);
}

// Usage (browser — pass a File object from an <input> element):
// convertFile(fileInput.files[0], "parquet");

Common Lisp

;;; Requires: drakma
;;; (ql:quickload :drakma)

(defparameter *api-key* "rep_live_xxxxxxxxxxxxxxxxxxxx")
(defparameter *base*    "https://reparatio.app/api/v1")

(defun convert-file (input-path target-format output-path)
  "Convert INPUT-PATH to TARGET-FORMAT and write the result to OUTPUT-PATH.
  INPUT-PATH may be a string or pathname; OUTPUT-PATH is written as binary."
  (let ((path (pathname input-path)))
    (multiple-value-bind (body status)
        (drakma:http-request
         (format nil "~A/convert" *base*)
         :method              :post
         :form-data           t
         :force-binary        t
         :additional-headers  `(("X-API-Key" . ,*api-key*))
         ;; File parameters are lists: (field-name pathname content-type filename)
         ;; String parameters are conses: (field-name . value)
         :parameters          `(("file"          ,path "application/octet-stream" ,(file-namestring path))
                                 ("target_format" . ,target-format)))
      (unless (= status 200)
        (error "API error ~A" status))
      (with-open-file (out output-path
                           :direction    :output
                           :element-type '(unsigned-byte 8)
                           :if-exists    :supersede)
        (write-sequence body out))
      (format t "Saved ~A~%" output-path))))

(convert-file "data.csv" "parquet" "data.parquet")

C#

using System.Net.Http;
using System.Net.Http.Headers;

const string ApiKey  = "rep_live_xxxxxxxxxxxxxxxxxxxx";
const string BaseUrl = "https://reparatio.app/api/v1";

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", ApiKey);
client.Timeout = TimeSpan.FromSeconds(120);

await using var fileStream = File.OpenRead("data.csv");
var content = new MultipartFormDataContent();
content.Add(new StreamContent(fileStream), "file", "data.csv");
content.Add(new StringContent("parquet"), "target_format");

var response = await client.PostAsync($"{BaseUrl}/convert", content);
response.EnsureSuccessStatusCode();

var bytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("data.parquet", bytes);
Console.WriteLine("Saved data.parquet");

Java

// Requires Java 11+ (java.net.http is in the standard library)
import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;
import java.nio.file.*;

public class ReparatioExample {
    static final String API_KEY  = "rep_live_xxxxxxxxxxxxxxxxxxxx";
    static final String BASE_URL = "https://reparatio.app/api/v1";

    public static void main(String[] args) throws Exception {
        byte[] fileBytes = Files.readAllBytes(Path.of("data.csv"));
        String boundary  = "----ReparatioBoundary";

        String body = "--" + boundary + "\r\n"
            + "Content-Disposition: form-data; name=\"file\"; filename=\"data.csv\"\r\n"
            + "Content-Type: application/octet-stream\r\n\r\n";
        byte[] bodyStart  = body.getBytes();
        byte[] fieldPart  = ("\r\n--" + boundary + "\r\n"
            + "Content-Disposition: form-data; name=\"target_format\"\r\n\r\n"
            + "parquet\r\n--" + boundary + "--\r\n").getBytes();

        byte[] requestBody = new byte[bodyStart.length + fileBytes.length + fieldPart.length];
        System.arraycopy(bodyStart, 0, requestBody, 0,                               bodyStart.length);
        System.arraycopy(fileBytes, 0, requestBody, bodyStart.length,                fileBytes.length);
        System.arraycopy(fieldPart, 0, requestBody, bodyStart.length + fileBytes.length, fieldPart.length);

        HttpClient client   = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/convert"))
            .header("X-API-Key", API_KEY)
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(BodyPublishers.ofByteArray(requestBody))
            .build();

        HttpResponse<byte[]> response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
        if (response.statusCode() != 200) throw new RuntimeException("API error: " + response.statusCode());

        Files.write(Path.of("data.parquet"), response.body());
        System.out.println("Saved data.parquet");
    }
}

Inspect a file (curl)

curl -X POST https://reparatio.app/api/v1/inspect \
  -F "file=@data.xlsx" \
  -F "preview_rows=5"

SQL query (curl)

curl -X POST https://reparatio.app/api/v1/query \
  -H "X-API-Key: rep_live_xxxxxxxxxxxxxxxxxxxx" \
  -F "file=@sales.csv" \
  -F "sql=SELECT region, SUM(amount) AS total FROM data GROUP BY region ORDER BY total DESC" \
  -F "target_format=csv" \
  -o summary.csv

Join two files (curl)

curl -X POST https://reparatio.app/api/v1/merge \
  -H "X-API-Key: rep_live_xxxxxxxxxxxxxxxxxxxx" \
  -F "file1=@customers.csv" \
  -F "file2=@orders.csv" \
  -F "operation=left" \
  -F "join_on=customer_id" \
  -F "target_format=parquet" \
  -o customers_with_orders.parquet

MCP Server

MCP access requires a Professional subscription ($79/mo). See Pricing.

How it works

The MCP server runs locally on your machine. When your AI assistant calls a tool, the server reads the file from your disk, sends it to the Reparatio API for processing, and writes the result back to disk — returning the output path to the assistant. Binary data never passes through the MCP protocol layer; only file paths and options travel as JSON.

Prerequisites

• Python 3.11+ — check with python3 --version
• A Reparatio API key — required for convert, merge, append, and query. inspect_file works without a key. Get one on the Pricing tab (Professional plan).

uvx (from uv) is the recommended way to run the server — no install step required:

curl -LsSf https://astral.sh/uv/install.sh | sh

Installation

Option A — run without installing (recommended):

uvx reparatio-mcp

Option B — install permanently:

pip install reparatio-mcp

Client Configuration

MCP is a client-side protocol. Your AI assistant application needs to support MCP tool calls. The LLM backend (Claude, GPT-4o, Grok, DeepSeek, Gemini, a local Ollama model, etc.) is configured separately inside each client — the MCP server works with any of them.

{
  "mcpServers": {
    "reparatio": {
      "command": "uvx",
      "args": ["reparatio-mcp"],
      "env": { "REPARATIO_API_KEY": "rp_YOUR_KEY" }
    }
  }
}

{
  "mcpServers": {
    "reparatio": {
      "command": "uvx",
      "args": ["reparatio-mcp"],
      "env": { "REPARATIO_API_KEY": "rp_YOUR_KEY" }
    }
  }
}

{
  "mcpServers": {
    "reparatio": {
      "command": "uvx",
      "args": ["reparatio-mcp"],
      "env": { "REPARATIO_API_KEY": "rp_YOUR_KEY" }
    }
  }
}

{
  "mcp": {
    "servers": {
      "reparatio": {
        "type": "stdio",
        "command": "uvx",
        "args": ["reparatio-mcp"],
        "env": { "REPARATIO_API_KEY": "rp_YOUR_KEY" }
      }
    }
  }
}

{
  "mcpServers": [
    {
      "name": "reparatio",
      "command": "uvx",
      "args": ["reparatio-mcp"],
      "env": { "REPARATIO_API_KEY": "rp_YOUR_KEY" }
    }
  ]
}

{
  "context_servers": {
    "reparatio": {
      "command": {
        "path": "uvx",
        "args": ["reparatio-mcp"],
        "env": { "REPARATIO_API_KEY": "rp_YOUR_KEY" }
      }
    }
  }
}

{
  "mcpServers": {
    "reparatio": {
      "command": "uvx",
      "args": ["reparatio-mcp"],
      "env": { "REPARATIO_API_KEY": "rp_YOUR_KEY" }
    }
  }
}

Environment Variables

Available Tools

Supported Formats

Example Prompts

Once connected, use natural language with your AI assistant:

Inspect ~/data/sales.csv and tell me about the schema.

Convert ~/data/sales.csv to Parquet.

Convert ~/data/report.xlsx, sheet "Q3", to CSV, selecting only the
"date", "region", and "revenue" columns.

Merge orders.csv and customers.csv on customer_id using a left join,
output as Parquet.

Append all the CSV files in ~/data/monthly/ into one file and save it
as ~/data/all_months.parquet.

Query ~/data/events.parquet: give me total revenue by region for 2025,
sorted descending, as a JSON file.

I have ~/data/legacy.csv from an old Windows system — fix the encoding
and convert it to Excel.

Convert ~/data/mainframe_export.dat — it's an EBCDIC cp037 fixed-width
file. Detect the column boundaries and convert it to Parquet.

Default Output Paths

Troubleshooting

Support

Send a message and we'll get back to you as soon as possible.

Merge Files

Stack rows from two or more files, or join two files on a shared column.

Append Files

Stack rows from two or more files vertically. Column mismatches are handled gracefully — missing values are filled with null.

SQL Query

Run a SQL query against an uploaded file. The table is always named data.

File Splitter

Split a large file into multiple smaller files, downloaded as a ZIP archive. Standard or Professional subscribers only.

What "beta" means here

This isn't a marketing term. The product works — it handles real files, real formats, and real edge cases every day. But data is endlessly weird, and no amount of internal testing catches everything that real users throw at a real tool.

There are bugs we haven't found yet. There are formats that almost work but not quite. There are error messages that are confusing. There are features that should exist but don't. You will find some of these things. We want you to tell us when you do.

What we'll do about it

We read every report. When something is broken, we fix it — usually within 48 hours for serious issues. When a feature request makes sense for the product, we build it. When we fix something you reported, we'll tell you.

We're not a large team with a ticket queue and a six-week sprint cycle. We're a small shop that moves fast. If you report a real bug today, there's a good chance it's fixed by tomorrow.

Current beta limits

These limits exist to help us understand load before we open things up fully. They will increase over the course of the beta — we'll announce increases as they happen.

Limits reset at midnight MDT. If you're hitting limits doing legitimate work, tell us — that's exactly the kind of feedback that helps us calibrate.

How to send feedback

• → Email us at feedback@reparatio.app for bug reports, especially if you can share the file or the error
• → Reply to your welcome email — it goes directly to us

The more specific you can be, the more useful it is. "The CSV export is broken" is hard to act on. "Converting a 40MB TSV with a pipe delimiter to Parquet returns a 422 error" is something we can fix today.

What happens at the end of the beta

The beta runs through April 15, 2026. Users who have been active will receive an offer for 50% off their first three months of a paid plan. No obligation, no pressure — but if Reparatio has been solving a real problem for you, it's a meaningful discount at the moment it matters most.

We'll send details before the beta ends.

Reparatio is the first product of Ordo Artificum LLC. We're building tools for people who work with messy data. If that's you, we're glad you're here.