Docs

The .chit bundle

A .chit file is how a meeting leaves Chitmonk without losing anything, and how one gets back in. It is an ordinary ZIP archive with a manifest and, for each meeting, the complete log of what happened in it. Importing a bundle reproduces the meeting exactly.

People make one with Export, then Chitmonk bundle (.chit) on a meeting, or Export all in the library for every meeting at once. They bring one in with Import in the library. The app accepts .chit and .zip.

Two files to keep next to this page: the JSON Schema and a sample bundle.

What is inside

manifest.json                 what the bundle holds, with a checksum for each file
meetings/<meeting-id>.json    one per meeting: its complete event log
audio/<meeting-id>.<ext>      only if the person chose to include kept audio

Nothing else may be in the archive. See what import checks.

manifest.json

{
  "format": "chitmonk-bundle",
  "version": 1,
  "exportedAt": "2026-10-09T23:01:57.490Z",
  "app": "Chitmonk docs sample",
  "meetings": [
    {
      "id": "01927f3a-0000-7000-8000-000000000001",
      "path": "meetings/01927f3a-0000-7000-8000-000000000001.json",
      "schema": 1,
      "events": 24,
      "sha256": "99c95bda1481d34ad33ced61eb87a9aea036c9fa97fed8028cca46214a4ca898"
    }
  ]
}
Field Type Meaning
format string Always chitmonk-bundle
version integer Version of this container. Currently 1
exportedAt string When it was written, as an ISO 8601 time
app string What wrote it. Chitmonk writes its own version; write the name of your tool
meetings array One entry per meeting, at most 4,000
meetings[].id string The meeting's id (a lowercase UUID)
meetings[].path string Exactly meetings/<id>.json
meetings[].schema integer Version of the event shapes in that file. Currently 1
meetings[].events integer How many events the file holds
meetings[].sha256 string SHA-256 of that file's exact bytes, in lowercase hex
meetings[].audio object Optional: path, mime, bytes, sha256 of the audio file

A meeting file

{ "schema": 1, "events": [ ... ] }

events is the meeting: an append-only list, oldest first. The current title, the transcript, who spoke, the action items are all worked out by replaying it. The event log lists every event and the rules for replaying.

Audio

Audio is in a bundle only when the person kept the audio for that meeting and ticked "Include the retained audio" when exporting. It is one file per meeting, stored without compression, named for its type:

mime starts with Extension
audio/webm .webm
audio/mp4 .m4a
audio/ogg .ogg

Chitmonk records Opus at about 14 MB per hour. Line times in the event log are positions in this recording.

Limits

What Limit
Files in the archive 4,000
One JSON file, unpacked 64 MiB
One audio file 512 MiB
Everything, unpacked 1 GiB
Events in one meeting 500,000
Any one piece of text (a title, a line, a note) 20,000 characters

Versions

There are two numbers and they change for different reasons. version in the manifest is the container: the file layout described on this page. schema is the shape of the events.

  • A bundle with a newer version or schema than the app knows is refused, with a message to update the app. It never guesses.
  • A meeting with an older schema is upgraded as it is read. The file is not changed.
  • Fields the app does not know are kept and written back out, so a bundle survives a round trip through an older or newer tool.

Both are 1 today.

What import checks

In this order, and it stops at the first failure. Nothing is saved from a bundle that fails.

  1. Only expected files. Every entry must be manifest.json, meetings/<uuid>.json or audio/<uuid>.<ext>. A folder stored as an entry of its own counts as an unexpected file, and so do the __MACOSX files some tools add. "That bundle contains files Chitmonk does not expect, so it was not imported."
  2. Size. The limits above. "That bundle is larger than Chitmonk will import."
  3. A manifest it recognises. Valid JSON with format set to chitmonk-bundle. "That file is not a Chitmonk bundle Chitmonk can read."
  4. A version it knows. "That bundle was made by a newer Chitmonk. Update the app, then import it again."
  5. Every listed meeting is there and intact. The file exists at meetings/<id>.json and its SHA-256 matches. "That bundle is damaged: its contents do not match its own checksums."
  6. Every event is valid. Known type, right fields, meetingId equal to the meeting's id, and the first event is MeetingCreated. An event type the app does not know fails here, with the same message as step 3.
  7. No voice data. An event carrying a key named embedding, embeddings, voiceprint, prototype, pcm or audio, at any depth, is refused. Voice fingerprints are never stored or exported, and the app will not take them in either.
  8. Audio, if listed, is there and intact. The same message as step 5.

What import does

  • A meeting the device does not have is added under the id it came with.
  • A meeting the device already has, with exactly the same events, is skipped.
  • A meeting with the same id but different events is added as a separate copy, with a new id and "(imported copy)" after its title. Nothing already on the device is ever overwritten or merged.