Flatfile alternative — a self-hosted embeddable importer

Mildport is a self-hosted alternative to Flatfile. You get the same embeddable CSV/Excel/PDF import experience your users expect, but the import engine runs as a Docker Compose stack in your infrastructure — customer files never leave your VPC, and licenses verify offline with no phone-home.

If you reached this page evaluating Flatfile, the question underneath is usually “where does my customers’ data go during an import?” With a cloud onboarding platform, the answer is “through the vendor’s cloud.” With Mildport, the answer is “nowhere it wasn’t already.”

Flatfile vs Mildport at a glance

	Flatfile (cloud)	Mildport (self-hosted)
Where the engine runs	Vendor cloud	Your infrastructure (Docker Compose or Helm)
Where customer files go	Uploaded to vendor cloud	Stay in your VPC
Embed model	Embeddable widget	Framework-agnostic custom element <mildport-import>
Column mapping	AI-assisted	Deterministic-first + optional BYO-AI judge (off by default)
Data cleanup	AI transforms in vendor cloud	Plain-language cleanups as reviewable before/after diffs — run privately, replay free
Schema setup	Blueprint defined in code	In code, in a no-code editor, or drafted from your API spec
Licensing	Cloud account / usage	Offline license key, no license server, no phone-home
Formats	CSV, Excel and more	CSV, TSV, XLSX, ODS, JSON, XML, PDF tables, OCR’d scans
Auditability	Vendor-managed	Event-sourced, replayable normalization + webhook audit trail
Import evidence	Vendor logs	Decision log per import + signed receipts a third party can verify offline
Agent access (MCP)	MCP server fronting Flatfile’s cloud	MCP server inside your deployment — agents import within your boundary, entitlement-gated
Tool or protocol?	A tool: the import runs, the trail stays with the vendor	A protocol: receipt, ambiguity ledger, changeset and a portable import contract — artifacts that outlive the run

Why teams switch from a cloud importer to Mildport

• Data residency by construction. Regulated data, enterprise security reviews and air-gapped deployments all get easier when files physically never leave your environment.
• Explainable matching. Visible match scores and a replayable, event-sourced pipeline mean an import is debuggable — not a black box. See How it works.
• No lock-in at the boundary. The widget is attributes in, DOM events out — no iframe, no proprietary SDK runtime wrapping your app.
• AI on your terms. The deterministic matcher does the predictable work; the optional AI judge re-ranks only the uncertain tail, with your model and the rationale shown in the grid.
• Cleaning without surrendering the data. Users fix messy files in plain language — the model proposes, the importer executes, and a before/after diff is approved by a person before anything changes. Accepted cleanups replay on the next similar file with no further AI calls. See AI data cleaning.
• Schema changes without releases. Flatfile’s Blueprint lives in code. Mildport’s target catalogs can live server-side too: edit fields in a no-code editor or draft them from your API spec, publish, and every embed updates on its next load — versioned, with one-click rollback.

When Flatfile is the better choice

Honestly: if you want a fully managed cloud service with zero infrastructure to run, and routing customer files through a third-party cloud is acceptable for your use case, a hosted platform is simpler to operate day one. Mildport earns its keep when data residency, security posture, or self-hosting are hard requirements — the situations where “just use the cloud” is the thing you’re explicitly trying to avoid.

What switching looks like

The integration surface is a single custom element. Install the package, define the element, drop it in:

npm install @capitality-io/mildport-widget

<mildport-import
  api-base-url="https://imports.your-infra.example"
  license-key="SIGNED_TENANT_KEY"
></mildport-import>

You define your targets and listen for import-applied — full walkthrough in the Quickstart. The engine you point it at is the self-hosted stack running in your own infrastructure.

FAQ

Is Mildport a self-hosted alternative to Flatfile? Yes — the same embeddable import experience, but the engine runs in your own infrastructure and customer files never leave your VPC.

What is the difference between Mildport and Flatfile? Flatfile is a cloud onboarding platform (data is uploaded to their cloud during import). Mildport is proprietary, self-hosted software that runs in your environment. Both embed as a widget; the difference is where the data and the engine live.

Does Mildport use AI to map columns like Flatfile? Mildport is deterministic first — an explainable matcher gives the same input the same answer. An optional, evidence-gated AI judge re-ranks only the uncertain columns; bring your own model, off by default.

When is Flatfile the better choice? When you want a fully managed cloud service with no infrastructure to run and sending files to a third-party cloud is acceptable. Mildport is the better fit when data residency or air-gapped deployment rule that out.

---

Want to see it on your own files? Start at mildport.com or read What is Mildport?