# Kinoku import format

Last updated: 2026-09-06. Rendered page: https://kinoku.app/import-format Raw file for AI agents: https://kinoku.app/import-format.md

Kinoku reads a file of your training and adds it to the app. You can build that file by hand, export it from another app, or ask an AI assistant to write it for you. This page lists the supported layouts, documented columns, worked examples, and the rules the reader follows. Nothing here needs a Kinoku account, and import stays free.

## Who this page is for

- You are moving to Kinoku and want your old history to come with you.
- You keep a training log in a spreadsheet or a note, and you want it in the app.
- You want an AI assistant to turn your log into a file Kinoku can read. Copy the [prompt at the end](#prompt-for-your-ai-assistant) and paste this page's raw link with it.

## Quick start

1. Make a CSV file. The first line is the header. Each set is one row.
2. Use the recommended header (below). Save the file as UTF-8 text with a `.csv` name.
3. Open Kinoku. Go to Settings, then Import & Export, then Import from CSV.
4. Pick your file. A review screen shows how each exercise name matched. Change any match you want.
5. Tap Import. You can undo the whole import later from Import History.

## Recommended shape

Use this header. It is the richest layout Kinoku reads, and it names its own units, so an AI assistant does not have to guess.

```csv format=B id=recommended
title,start_time,end_time,description,exercise_title,superset_id,exercise_notes,set_index,set_type,weight_kg,reps,distance_km,duration_seconds,rpe
Upper A,2026-03-02 07:05:00,2026-03-02 08:10:00,Felt strong,Bench Press (Barbell),,,0,warmup,40,10,,,
Upper A,2026-03-02 07:05:00,2026-03-02 08:10:00,Felt strong,Bench Press (Barbell),,,1,normal,80,5,,,8
Upper A,2026-03-02 07:05:00,2026-03-02 08:10:00,Felt strong,Bench Press (Barbell),,,2,normal,80,5,,,8.5
Upper A,2026-03-02 07:05:00,2026-03-02 08:10:00,Felt strong,Bent Over Row (Barbell),A,,0,normal,70,8,,,
Upper A,2026-03-02 07:05:00,2026-03-02 08:10:00,Felt strong,Overhead Press (Barbell),A,,1,normal,45,8,,,
Upper A,2026-03-02 07:05:00,2026-03-02 08:10:00,Felt strong,Pull up,,,0,normal,,8,,,
Upper A,2026-03-02 07:05:00,2026-03-02 08:10:00,Felt strong,Plank,,,0,normal,,,,60,
Lower A,2026-03-04 18:00:00,2026-03-04 19:00:00,,Squat (Barbell),,,0,normal,100,5,,,9
Lower A,2026-03-04 18:00:00,2026-03-04 19:00:00,,Romanian Deadlift (Barbell),,,0,normal,90,8,,,
Lower A,2026-03-04 18:00:00,2026-03-04 19:00:00,,Treadmill Running,,,0,normal,,,3,900,
```

That file makes two workouts. The first has seven exercises, one warmup set, a superset of two exercises (they share the label `A`), a bodyweight pull up, and a plank held for 60 seconds. The second has a squat, a deadlift, and a 3 km treadmill run.

### Columns

| Column | Needed? | What it holds |
|---|---|---|
| `title` | yes | The workout name. Rows with the same `title` and `start_time` join into one workout. |
| `start_time` | yes | When the workout started. See [Dates](#dates-numbers-and-delimiters). |
| `end_time` | no | When it ended. Kinoku uses it to work out the duration. |
| `description` | no | A note for the whole workout. |
| `exercise_title` | yes | The exercise name. See [Exercise names](#exercise-names). |
| `superset_id` | no | A label. Rows that share a label are one superset. Leave blank for a normal set. |
| `exercise_notes` | no | A note for this set. |
| `set_index` | no | The order of the set inside the exercise. Start at 0. |
| `set_type` | no | `normal`, `warmup`, `dropset`, or `failure`. Blank means a normal working set. |
| `weight_kg` | no | The weight in kilograms. Leave blank for a bodyweight move. |
| `reps` | no | How many reps. |
| `distance_km` | no | Distance in kilometers, for cardio. |
| `duration_seconds` | no | Time in seconds, for a plank, a hold, or a run. |
| `rpe` | no | How hard the set felt, 1 to 10. |

## Other layouts Kinoku reads

Kinoku also reads the export files from a few well-known apps. Each layout below is detected on its own, so you can hand Kinoku a file straight from that app.

### Strong

```csv format=A id=strong-shape
Date,Workout Name,Exercise Name,Set Order,Weight,Reps,Distance,Seconds,Notes,Workout Notes,RPE,Workout Duration
2026-03-02 07:05:00,Upper A,Bench Press (Barbell),1,80,5,,,,,8,3900
2026-03-02 07:05:00,Upper A,Pull up,1,,8,,,,,,3900
```

This layout has no unit column. Kinoku reads `Weight` as kilograms. Convert pounds before you save the file, or use the FitNotes layout instead, which has a pounds column.

Strong 6.2.4 (checked September 2026) writes a different file: semicolon-separated, every field quoted, a `Weight (kg)` column in kilograms whatever the app's display unit, and one `Rest Timer` row per exercise. Kinoku, up to and including 1.3.0, detects that file but drops the weight and turns the rest-timer row into an empty set. The fix is tracked, so keep the original file and check the preview before you save.

### Hevy

Hevy's export is the recommended shape above, with two differences. Hevy names the weight and distance columns after your unit setting, so an account set to pounds writes `weight_lbs` and `distance_miles`, and it writes dates like `6 Sep 2026, 18:00`, with the month in the language Hevy is set to (`6 Sept. 2026` in German, `6 9月 2026` in Japanese). Kinoku reads both column forms and every Hevy language, and converts pounds and miles for you, from the update after 1.2.0. Exercise names come out in that language too, so export with Hevy set to English if you can. If your Kinoku refuses a Hevy file, update it from Google Play and keep the file.

```csv format=B id=hevy-lbs
"title","start_time","end_time","description","exercise_title","superset_id","exercise_notes","set_index","set_type","weight_lbs","reps","distance_miles","duration_seconds","rpe"
"Push","6 Sep 2026, 18:00","6 Sep 2026, 19:05","","Bench Press (Barbell)",,"",0,"warmup",95,10,,,
"Push","6 Sep 2026, 18:00","6 Sep 2026, 19:05","","Bench Press (Barbell)",,"",1,"normal",175,5,,,8
"Push","6 Sep 2026, 18:00","6 Sep 2026, 19:05","","Treadmill Running",,"",0,"normal",,,1,600,
```

### FitNotes and Jefit

```csv format=D id=fitnotes-kg
Date,Exercise,Category,Weight (kgs),Weight (lbs),Reps,Distance,Distance Unit,Time,Comment
2026-03-02,Squat (Barbell),Legs,100,,5,,,,felt good
2026-03-04,Bench Press (Barbell),Chest,80,,5,,,,
```

This layout names its units. When both `Weight (kgs)` and `Weight (lbs)` are present, Kinoku reads the kilograms column and ignores the pounds column. If you only have pounds, use a header with just `Weight (lbs)`:

```csv format=D id=fitnotes-lbs
Date,Exercise,Category,Weight (lbs),Reps,Comment
2026-03-02,Squat (Barbell),Legs,225,5,felt good
```

### Minimal

The smallest layout Kinoku reads. Good for a quick log.

```csv format=C id=minimal
Date,Exercise,Weight,Reps,Notes
2026-03-02,Squat (Barbell),100,5,
2026-03-02,Bench Press (Barbell),80,5,
2026-03-04,Deadlift,120,3,top set
```

This layout has no unit column, so Kinoku reads `Weight` as kilograms. One workout is made per date. A set of reps written as `10/8/6` in one row becomes three sets.

## Dates, numbers, and delimiters

- **Dates.** Kinoku reads several date shapes: `2026-03-02`, `2026-03-02 18:05`, `2026-03-02T18:05:00`, `03/02/2026` (month first), `02.03.2026` (day first), and a few Asian shapes. The clearest shape is `YYYY-MM-DD` or `YYYY-MM-DD HH:MM:SS`. A slash date like `03/04/2026` is read month first, so it means March 4. Times are read in your phone's local time.
- **A date Kinoku cannot read lands the workout on 1 January 1970.** If you see workouts on that date after an import, the date column was in a shape Kinoku did not recognize. Use `YYYY-MM-DD` to be safe.
- **Numbers.** A decimal can use a dot or a comma. Both `22.5` and `22,5` mean 22 and a half.
- **Delimiter.** Kinoku reads comma files and semicolon files. It picks the one your header uses.

```csv format=C id=semicolon
Date;Exercise;Weight;Reps;Notes
2026-03-02;Squat (Barbell);82,5;5;deload week
```

- **Text.** Save the file as UTF-8. A byte-order mark is fine. Quoted fields and line breaks inside a quoted field are fine.
- **Extra columns are ignored.** Kinoku reads the columns it knows and skips the rest. Blank lines are skipped.

## Units

- The recommended layout uses `weight_kg` and `distance_km`, so units are clear.
- The Strong and Minimal layouts have no unit column. Kinoku reads weight as kilograms. Convert pounds first.
- The FitNotes layout names its units with the header (`Weight (kgs)` or `Weight (lbs)`) and a `Distance Unit` column.
- A Hevy export names its units in the header too: `weight_kg` and `distance_km`, or `weight_lbs` and `distance_miles`. Kinoku converts the pound and mile forms.
- Time is in seconds. The FitNotes `Time` column also reads `H:MM:SS` and `MM:SS`.

## Exercise names

Kinoku has more than 1,300 built-in exercises. When it reads a name, it tries to match one:

1. An exact name match wins.
2. Common short names expand first. `rdl` becomes Romanian Deadlift, `ohp` becomes Overhead Press, `bb row` becomes a barbell row.
3. If nothing matches well, Kinoku makes a new custom exercise with that name.

You see every match on the review screen before anything is saved, and you can change any of them.

Tips for the best match:

- Use the built-in name when you can. The pattern is `Movement (Equipment)`, like `Bench Press (Barbell)` or `Romanian Deadlift (Barbell)`. Some names have no equipment tag, like `Pull up` or `Plank`.
- The full list of built-in names is at [/import-format/exercise-names.txt](/import-format/exercise-names.txt). An AI assistant can read that list and pick exact names, so every set matches and no custom exercise is made.

## What is not imported from a CSV

A CSV brings in workouts and their sets. It does not bring in:

- Routines, planned calendar workouts, or training programs.
- Custom metrics, body measurements, or progress photos.
- Steps or GPS routes.

Two paths cover the rest. A full Kinoku ZIP backup restores everything, because it is a copy of the app's own data. And you can paste a plan as text to build routines. See [Routines from pasted text](#routines-from-pasted-text). Kinoku can also look at repeated sessions in your imported history and suggest routines on the review screen.

GPS runs from Strava have their own reader. See the [Strava import](/features/strava-import) page.

## Importing the same file twice

For the Kinoku layouts, give each workout a stable id and Kinoku will not import it twice. In Kinoku CSV that is the `workout_id` column; in Kinoku Import JSON it is the `id` on each workout. Kinoku matches a workout by its date and its id together. So the same id on a different day in another file still imports, and you do not need ids to be unique across files. On a second import, a workout whose date and id were already brought in is skipped, and Kinoku tells you how many it skipped. Delete a workout for good and it is freed, so it imports again next time. An id can be up to 64 characters of letters, numbers, and `. _ : -`.

The other CSV layouts (Strong, FitNotes, Hevy, and the minimal shape) have no id, so importing one of those twice makes two copies. If that happens, open Import History on the Import screen and undo the extra import. Each import can be undone on its own.

## File size

There is no hard limit. The test suite includes a file with 4,000 rows. A very large file just takes a little longer on the review step.

## Kinoku Import JSON

One JSON file can carry your full history and your future plan together: past workouts, routines, a dated calendar plan, recurring days, custom metrics, and per-lift training maxes. It is the best shape to ask an AI assistant for when you want routines and a plan, not only history. This layout is new. If your app does not read it yet, update Kinoku from Google Play.

```json
{
  "format": "kinoku-import",
  "version": 1,
  "units": { "weight": "kg", "distance": "km" },
  "workouts": [
    { "date": "2026-08-18T18:05", "name": "Upper A", "notes": "felt strong",
      "exercises": [
        { "exercise": "Bench Press (Barbell)",
          "sets": [ { "weight": 60, "reps": 10, "type": "warmup" }, { "weight": 100, "reps": 5, "rpe": 8, "rir": 2 } ] },
        { "exercise": "Plank", "sets": [ { "time_s": 60 } ] },
        { "exercise": "Running", "sets": [ { "distance": 5, "time_s": 1500 } ] } ] }
  ],
  "routines": [
    { "name": "Upper A", "role": "main",
      "exercises": [
        { "exercise": "Bench Press (Barbell)", "tempo": "3010",
          "sets": [ { "pct_tm": 65, "reps": 5, "rest_s": 180 }, { "pct_tm": 85, "reps": 5, "reps_high": 8, "rpe": 9 } ] } ] }
  ],
  "plan": {
    "scheduled": [ { "date": "2026-09-01", "routine": "Upper A" }, { "date": "2026-09-03", "type": "run", "title": "Tempo", "distance": 8 } ],
    "recurring": [ { "routine": "Upper A", "days": ["MON", "THU"], "start": "2026-09-08", "weeks": 12 } ]
  },
  "metrics": [ { "name": "Sleep quality", "type": "scale", "scale_min": 1, "scale_max": 5 } ],
  "metric_logs": [ { "metric": "Sleep quality", "date": "2026-08-18", "scale": 4 } ],
  "training_max": [ { "exercise": "Bench Press (Barbell)", "value": 110 } ]
}
```

The example above is the public authoring subset, not an exhaustive schema dump. A current Kinoku **Export for AI** file is the canonical template for less-common optional fields. The shape above is stable: `format` and `version` come first, weights follow `units.weight`, and exercises are named the same way as in the CSV layouts. Inside a set you can use `weight`, `reps`, `distance` (in your `units.distance`), and `time_s` (seconds, for a plank, a hold, or cardio like a run or a row).

## Kinoku CSV

A flat layout Kinoku owns, for people who prefer a spreadsheet but want more than the minimal layout. Only `date` and `exercise` are required. Every other column is optional, and the order is free. This layout is new. If your app does not detect it yet, update Kinoku from Google Play.

```csv format=K id=kinoku-csv
date,workout,workout_id,exercise,set,type,weight,weight_unit,reps,rir,rpe,distance,distance_unit,duration_s,superset,notes,workout_notes,workout_duration_min,body_weight
2026-03-02,Upper A,,Bench Press (Barbell),1,warmup,40,kg,10,,,,,,,,,62,82
2026-03-02,Upper A,,Bench Press (Barbell),2,working,100,kg,5,2,8,,,,,,,62,82
2026-03-02,Upper A,,Pull up,1,working,,,8,1,,,,,,,,62,82
```

`weight_unit` reads `kg`, `lb`, or `lbs`, and blank means kilograms. `distance_unit` reads `km`, `mi`, or `m`, and blank means kilometers. `type` reads `warmup`, `working`, `failure`, `drop`, or `rest_pause`. `body_weight` records what you weighed, so bodyweight moves like the pull up carry the right load.

## Routines from pasted text

You do not always need a file. On the Import screen you can paste a plan as text, and Kinoku turns it into routines. It reads lines like these:

```text id=routine-paste
Monday: Upper
Bench Press: 3 sets x 5 reps
Bent Over Row: 3 sets x 8-10 reps
Plank: 3 sets x 45 seconds

Thursday: Lower
Squat: 3 sets x 5 reps
Romanian Deadlift: 3 sets x 8 reps
```

Day headers like `Monday:` or `Day 1:` start a new routine. Rep ranges and time targets are read too.

## Export for AI

Kinoku can also go the other way. In **Settings → Data → Export for AI**, pick how
much to include and share the file with your assistant. It is a small text file, so
you can hand your training to an AI app without typing it out.

The file **is** a Kinoku Import JSON document, the same one described above. So the
assistant can read it, and anything it writes back in the same shape imports
straight away.

Two extra keys ride along. Kinoku ignores both when reading a file, so an export
you got from Kinoku can be imported back into Kinoku unchanged.

```json id=export-extras
{
  "format": "kinoku-import",
  "version": 1,
  "ai_instructions": [
    "This is a Kinoku training export. Weights are kilograms and distances are kilometres."
  ],
  "summary": {
    "date_from": "2026-07-01",
    "date_to": "2026-08-25",
    "workout_count": 18,
    "set_count": 214,
    "top_exercises": ["Bench Press (Barbell)", "Squat (Barbell)"],
    "body_weight_kg": 82.0,
    "body_weight_trend": "steady"
  },
  "workouts": [
    {
      "id": "kinoku-1042",
      "date": "2026-08-24",
      "name": "Push",
      "exercises": [
        { "exercise": "Bench Press (Barbell)", "sets": [ { "weight": 100, "reps": 5 } ] }
      ]
    }
  ]
}
```

- **`ai_instructions`** tells the assistant what the file is and what to send back.
- **`summary`** is a short preamble so it can get its bearings without adding up
  every set first. Everything in it comes from the workouts below it.

### What the file leaves out

Some things are never exported, and there is no setting to turn them on:

- Cycle and pregnancy tracking. The export has no way to read it.
- Progress photos.
- GPS routes.

Health Connect readings are off unless you switch them on.

### Sending it back

Ask for a plan, then share the assistant's file back to Kinoku. You can send it
straight from the chat app: Kinoku appears in the share sheet.

**Your old workouts will not be duplicated.** Every workout in an export carries an
id like `kinoku-1042`, and Kinoku skips an id it has already seen. If the assistant
repeats your history back, those rows are skipped and only the new ones import. You
still see the preview first, and Undo still removes the whole import.

That skip covers **workouts**. Routines, planned days and metrics have no id of their
own, so if the assistant repeats those back they come in again as copies. Ask it for
only the new parts, and use Undo on the import screen if a reply brings back more than
you wanted.

### About the file name

The file is named `.txt` even though it holds JSON, because more AI apps accept a
`.txt` upload. Kinoku reads the contents, not the file name, so the name never
changes what it does.

## Prompt for your AI assistant

Copy this, paste it into your assistant, and paste your training log after it.

```text id=ai-prompt
I want to import my training history into Kinoku (Android). Read the import format at https://kinoku.app/import-format.md and turn the log I paste below into ONE CSV file in the recommended shape (format B).

Rules:
- Use exactly this header line: title,start_time,end_time,description,exercise_title,superset_id,exercise_notes,set_index,set_type,weight_kg,reps,distance_km,duration_seconds,rpe
- Dates as yyyy-MM-dd HH:mm:ss.
- Weights in kilograms. Convert pounds and round to 2 decimals.
- One row per set. set_index starts at 0 for each exercise.
- set_type is normal, warmup, dropset, or failure.
- Use Kinoku built-in exercise names when you can, in the pattern Movement (Equipment), for example Bench Press (Barbell).
- Leave a cell blank when you do not have the value. Do not invent data.

Give me the CSV in one code block, then list anything you could not map.
```

## Version notes

- 2026-08 adds the Export for AI file: the same layout, going the other way,
  with two keys Kinoku ignores on the way back in.
- 2026-08 first version. Documents the CSV layouts Kinoku reads, plus the Kinoku CSV and Kinoku Import JSON layouts and the id-based skip for re-imports. The two Kinoku layouts and the skip need a current app version, so update Kinoku if your app does not read them yet. Every example on this page is checked against the app's own reader by an automated test.
