Each platform has a specific pattern for receiving data from KinesteX.

SDK Platforms (Swift, Kotlin, React Native, React-TS, Flutter): Use the callback function provided by the SDK with typed message enums.

HTML/JS: Set up a message event listener manually since there's no SDK wrapper.

Events for app startup, loading, and exit.

streak_extended Data Structure:

1{
2  current_streak: number,    // Current streak count (days)
3  longest_streak: number,    // User's longest streak ever
4  last_activity_date: string // ISO date of the activity that extended the streak
5}

Events for workout lifecycle and statistics.

workout_ended exit_type values:

workout_overview Data Structure:

1{
2  workout_title: string,            // Workout name
3  workout_id: string,               // Unique workout ID
4  target_duration_seconds: number,  // Target workout duration (seconds)
5  workout_duration_seconds: number, // Total wall-clock session time
6                                    // (includes rest, transitions, pauses).
7                                    // For challenges/assessments this equals
8                                    // total_time_spent (no wall-clock concept)
9  total_time_spent: number,         // Active exercise time only (seconds)
10  completed_reps_count: number,     // Total completed reps
11  target_reps_count: number,        // Total target reps
12  calories_burned: number,          // Calories (2 decimal places)
13  completion_percentage: number,    // Completion % (2 decimals)
14  total_mistakes: number,           // Total mistake count
15  accuracy_score: number,           // Overall accuracy (0-100)
16  efficiency_score: number,         // Efficiency metric (0-100)
17  total_exercise: number,           // Number of exercises
18  actual_hold_time_seconds: number, // Time in correct position
19  target_hold_time_seconds: number  // Target hold time
20}

Note: Use workout_duration_seconds to display or log the full session time (including rest periods). Use total_time_spent if you only need active exercise time.

Events for individual exercise tracking.

exercise_completed Data Structure:

1{
2  exercise_title: string,        // Exercise name
3  time_spent: number,            // Seconds spent
4  repeats: number,               // Reps completed
5  total_reps: number,            // Required reps
6  total_duration: number,        // Countdown time
7  perfect_hold_position: number, // Time in perfect hold position (seconds).
8                                 // 0 for non-hold exercises
9  calories: number,              // Calories burned
10  exercise_id: string,           // Exercise ID
11  exercise_index: number,        // 1-based position of the completed exercise
12  total_exercises: number,       // Total number of exercises in the workout
13  mistakes: Array<{              // Mistakes made
14    mistake: string,
15    count: number
16  }>,
17  average_accuracy?: number      // Average accuracy (0-1, optional)
18}

exercise_overview Item Structure:

1{
2  exercise_title: string,        // Exercise name
3  exercise_id: string,           // Unique exercise ID
4  time_spent: number,            // Time on exercise (seconds)
5  perfect_hold_position: number, // Time in correct position (timer-based)
6  repeats: number,               // Reps completed
7  total_required_reps: number,   // Target reps
8  total_required_time: number,   // Target time (seconds)
9  calories: number,              // Calories (2 decimal places)
10  mistakes: Array<{              // Detailed mistake breakdown
11    mistake: string,
12    count: number
13  }>,
14  mistake_count: number,         // Total mistakes for exercise
15  accuracy_reps?: number[],      // Per-rep accuracy scores (optional)
16  average_accuracy?: number      // Average accuracy 0-100 (optional)
17}

Events for camera tracking and frame detection.

Events for workout plans and programs.

Note on plan tracking: When you launch a plan workout directly via the SDK, you can pass planId, planType, and progressWorkoutId in the initial PostMessage configuration so the SDK associates the workout session with the correct plan. After the workout finishes, you'll receive either plan_progression_saved (success) or plan_progression_failed (error). See Plan Context configuration for details.

Events for challenge mode.

Events for leaderboard functionality.

highlighted_user Data Structure:

1{
2  username: string,  // User's username
3  score: number,     // User's score
4  position: number   // Leaderboard position (1-based)
5}

Events for app navigation.

Events dispatched when a user submits feedback.

Training Feedback Payload (source: "training_feedback"):

1{
2  type: "feedback_submitted",
3  source: "training_feedback",
4  rating: number,              // User rating (e.g., 1-5)
5  is_like: boolean,            // Whether the user liked the workout
6  description: string,         // Optional text feedback
7  workout_id: string,          // Workout ID
8  workout_title: string        // Workout name
9}

Per-Exercise Feedback Payload (source: "exercise_feedback"):

1{
2  type: "feedback_submitted",
3  source: "exercise_feedback",
4  workout_id: string,          // Workout ID
5  workout_title: string,       // Workout name
6  feedbacks: Array<{           // Per-exercise feedback entries
7    exercise_id: string,       // Exercise ID
8    exercise_title: string,    // Exercise name
9    is_like: boolean,          // Whether the user liked the exercise
10    description: string        // Optional text feedback
11  }>
12}

Events related to workout session saving and motion recording uploads. These events are only dispatched when \shouldSendStats: true\ is passed in the SDK configuration.

workout_session_saved Data Structure:

1{
2  session_id: number,            // Backend-assigned session ID
3  workout_title: string,         // Name of the workout
4  accuracy_score: number,        // Overall accuracy (0-100)
5  efficiency_score: number,      // Efficiency score (0-100)
6  completion_percentage: number,  // How much of the workout was completed (0-100)
7  completed_reps_count: number,  // Total reps completed
8  calories_burned: number        // Estimated calories burned
9}

motion_upload_progress Data Structure:

1{
2  completed: number,  // Number of exercise recordings uploaded so far
3  total: number       // Total number of exercise recordings to upload
4}

Events for errors, warnings, and active time tracking.

ios_video_fallback_activated Payload:

1{
2  type: "ios_video_fallback_activated",
3  reason: string,      // e.g. "video_stuck_at_metadata"
4  videoUrl: string,    // URL of the affected video
5  readyState: number,  // HTMLMediaElement readyState at the time of fallback
6  userAgent: string    // Device user agent string
7}

Use this event for analytics or to surface a notice in your UI when iOS playback degrades. Only listen for it if you need visibility into iOS playback issues — no integrator action is required.

Events dispatched when a user exits an assessment before completing it.

assessment_exit Payload:

1{
2  type: "assessment_exit",
3  data: {
4    exerciseId: string  // The assessment exercise identifier
5  }
6}

assessment_exit_results Payload:

1{
2  type: "assessment_exit_results",
3  data: {
4    exerciseId: string  // The assessment exercise identifier
5  }
6}

Use \assessment_exit\ to detect when users abandon an assessment mid-session, and \assessment_exit_results\ to detect when they leave after viewing their results.

AI-powered health assessments with two event types:

• assessment_overview: Sent when results page loads
• assessment_completed: Sent when user clicks restart or finish

Common Fields (All Assessments):

Assessment Types:

• Mobility: TUG (tug), Gait Speed Test (gaitspeedtest)
• Balance: SLS (sls), SBSS (sbss), STSS (stss), Full Tandem (fulltandem)
• Functional: STS (sts), Five Times STS (fivetimessts), FRT (frt)
• Range of Motion: Shoulder ROM (romshoulder)
• Games: Balloon Pop (balloonpop), Color Chase (colorchase), Alien Squat Shooter (aliensquatshooter)

Risk Levels:

TUG (Timed Up and Go) - assessmentType: "tug"

Stand-walk-turn-return-sit timing test.

Gait Speed Test - assessmentType: "gaitspeedtest"

Walking speed measurement over 4 meters.

SLS (Single Leg Stand) - assessmentType: "sls"

Risk Calculation:

• Low: Min time >=20s AND symmetry good (difference <=5s)
• Moderate: Min time >=10s AND average >=15s
• High: All other cases

SBSS (Side-by-Side Stand) - assessmentType: "sbss"

Risk Calculation:

• High: Feet moved OR (time <7s AND sway >=30%)
• Moderate: Time >=7s AND sway <30%
• Low: Time >=9.5s AND sway <15%

STSS (Semi-Tandem Stand) - assessmentType: "stss"

Risk calculation same as SBSS.

Full Tandem Stand - assessmentType: "fulltandem"

Risk Calculation:

• Low: Time >=10s AND no feet movement
• Moderate: Time >=5s
• High: Time <5s

STS (30-Second Sit-to-Stand) - assessmentType: "sts"

Five Times STS - assessmentType: "fivetimessts"

FRT (Functional Reach Test) - assessmentType: "frt"

End Reason Values:

• "Feet moved out of zone"
• "User left zone"
• "User turned forward"
• "Arm dropped completely"
• "Reference lost"
• "Unhandled state"

Risk Calculation:

• High: Test not completed OR reach <=15cm
• Moderate: Reach 15-25cm
• Low: Reach >25cm

Shoulder ROM - assessmentType: "romshoulder"

A quick range-of-motion check for the shoulders. The user stands facing the camera and lifts one arm at a time straight out to the side (shoulder abduction), as high as comfortably possible. The system tracks the peak abduction angle reached by each arm, compares left and right sides, and flags meaningful asymmetry.

Useful for tracking recovery, spotting asymmetry, and observing mobility improvements session over session.

Notes:

• All angle measurements are in degrees.
• Numeric values are rounded to 0 decimal places.
• romAsymmetric is computed by comparing romSymmetryDelta against romSymmetryFlagDegrees.

Balloon Pop - assessmentType: "balloonpop"

Mastery Titles:

Color Chase - assessmentType: "colorchase"

Mastery Titles:

Alien Squat Shooter - assessmentType: "aliensquatshooter"

Mastery Titles:

Health Benefits (All Games)

Included in payload for all game types.

1healthBenefits: {
2  heartDiseaseReduction: number,  // Estimated % reduction (max 15)
3  diabetesReduction: number,      // Estimated % reduction (max 20)
4  obesityReduction: number,       // Estimated % reduction (max 10)
5  depressionReduction: number     // Estimated % reduction (max 15)
6}

Health Benefit Calculation:

reduction = min((gameScore / 100) * maxReduction, maxReduction)

Complete Workout Flow:

1. kinestex_launched - Application starts

2. workout_opened - User views workout details

3. workout_started - Workout begins

4. returned_camera_frame / left_camera_frame - Frame tracking

5. Multiple exercise_completed - Each exercise finished

6. workout_overview - Summary statistics

7. exercise_overview - All exercises summary

8. workout_completed - User exits statistics

9. exit_kinestex - Application closed

Challenge Flow:

1. challenge_started - Challenge begins

2. exercise_completed - Exercise finished

3. challenge_completed - Challenge complete

4. challenge_exit - Exit from challenge

Assessment Flow:

1. kinestex_launched - Application starts

2. Assessment performed (user follows on-screen instructions)

3. assessment_overview - Results page loads with all metrics

4. assessment_completed - User clicks restart or finish

5. assessment_exit_results - User exits from results screen (or assessment_exit if they exit early)

6. exit_kinestex - Application closed