Data Platform · Backend only

You build the front end. We handle the backend.

Cycler ingestion, format standardization, parser maintenance, and cloud storage — handled. You access the data from Python and build whatever notebooks, dashboards, or models your team needs on top.

Book a 15-min walkthrough $1,500 / month 
# Connect to your data
from micantis import MicantisAPI
api = MicantisAPI()

# Every cycler. Already normalized.
data = api.get_data_table(barcode="LOT-2024-0847")
df = api.download_parquet_file(data[0]["id"])

# Cycle summaries are already computed
df.columns
# → ['cycle', 'capacity_ah', 'energy_wh',
#    'dcir_mohm', 'voltage_v', 'current_a', ...]

# Your models. Your dashboards. Your IP.
predictions = your_model(df)

Two situations where this fits.

Most teams want the full Web App. The Data Platform makes sense in two specific cases.

Early-stage on a budget

$1,500 / month gets you a real data backend without committing to a full platform. When the team grows into needing dashboards, QC workflows, or reports, your data infrastructure doesn't change — the Micantis Web App adds the UI on top of the same data layer.

Custom workflows, custom UI

If your engineers have built notebooks, models, or dashboards specific enough that no off-the-shelf app fits, skip writing the ingestion and parser layer yourself. Bring your front end. We handle the backend.

A data layer, not an app.

The Data Platform handles ingestion, normalization, and storage. You bring the analytics.

What's included

  • Auto ingestion from every cycler in your lab
  • Standardized format across cyclers — one schema, one set of column names and units
  • Parser maintenance as cycler formats and firmware change
  • Cycle summaries pre-computed (capacity, energy, efficiency, DCIR)
  • Per-cell metadata read and write
  • Python API — pip install micantis
  • Parquet downloads for direct DataFrame loading
  • Cloud storage for raw + processed data

What's not included

  • No web app or browser UI
  • No dashboards — build your own in Grafana, Streamlit, or Jupyter
  • No quality control workflows or automated reports
  • No spec evaluation or pass / fail engine
  • No alerts, scheduled reports, or notifications
  • No MOOSE AI assistant

Need any of these? The Micantis Web App adds the full UI on top of the same data layer.

From cycler file to clean Parquet.

Files land, formats get standardized, parsers stay current. You query the result in Python.

Supported Cyclers

We maintain the parsers as cycler vendors push firmware changes. Your pipeline keeps working without engineering time on your side.

Arbin Maccor Neware Bitrode BioLogic Novonix PEC Gamry Basytec Landt 50+ more

Works With Your Stack

Parquet is the standard for analytical workloads. Load into pandas, Polars, Spark, DuckDB, Databricks, or any tool that reads columnar data. No proprietary formats.

# Download a full dataset as Parquet
df = api.download_parquet_file(data_id)

# Or filter by cycle range
df = api.download_parquet_file(
    data_id,
    cycles="1-50"       # first 50 cycles
)

# Last 10 cycles
df = api.download_parquet_file(
    data_id,
    cycles="-10"       # from the back
)

# Embedded metadata comes with the file
meta = api.unpack_parquet(df)
# → cell info, timestamps, cycle counts

Search, Filter & Metadata

Find what you need. Tag cells with your own properties. Build your data pipeline around the API.

Find Data

Search and filter your data table by barcode, date range, station, channel, cell test name, or data type. Get back structured results you can iterate over.

Per-Cell Metadata

Read and write custom metadata on any cell. Tag with chemistry, supplier, lot number, grade — whatever your workflow needs. Query it back in wide format for batch analysis.

Data Operations

  • stitch_data() — combine interrupted tests
  • clean_data() — auto-fixup, filter, parametric cleaning
  • get_changelog() — track every data modification
  • get_duplicate_files() — find similar uploads
# Search your data
results = api.get_data_table(
    search="NMC811",
    start_date="2024-01-01",
    end_date="2024-06-30"
)

# Read per-cell metadata
meta = api.get_cell_metadata(
    cell_ids=["CELL-001", "CELL-002"],
    metadata=["chemistry", "supplier", "lot"]
)

# Write your own properties back
api.write_cell_metadata([{
    "cell": "CELL-001",
    "field": "grade",
    "value": "A"
}])

# Track changes since last sync
changes = api.get_changelog(
    since="2024-06-01T00:00:00Z"
)

Bring your own everything else.

The Data Platform is the foundation. Everything you build on top of it stays yours.

Your Analysis

Write your own models, your own statistical tests, your own degradation fits. The data layer doesn't care what you do with the data.

Your Dashboards

Build in Grafana, Streamlit, Jupyter, or whatever your team already uses. Pull from the API. We're not replacing your tools.

Your IP

Your models, your code, your insights — they stay yours. We provide the plumbing. You own everything that runs on top of it.

Install from PyPI
pip install micantis[parquet]
View on PyPI →

If your team needs the app later, the data layer doesn't change.

The Micantis Web App is the same Data Platform with a browser UI on top. Anything you've built on the Python API keeps working.

Same data, plus a UI

Dashboards, search, plotting, and comparisons in the browser — driven by the same standardized data you've been querying from Python.

QC & reporting

Spec-driven pass / fail evaluation, automated reports, and quality workflows for incoming inspection, manufacturing, and R&D.

MOOSE AI assistant

Ask questions about your test data in plain language. Learn more →

$1,500 / month. Book a 15-minute walkthrough.
See the API, ask anything, decide whether it fits.
Book a Walkthrough →