Secondary Muscles Involved in Exercises: Dataset Schema, Structure, and Query Guide

The Exercises Dataset stores secondary muscles involved in exercises as a standardized array of strings in the secondary_muscles field, providing a complete taxonomy of supporting muscle groups recruited alongside primary targets for all 1,324 exercise records.

Understanding secondary muscles involved in exercises is essential for building intelligent fitness applications. The open-source repository hasaneyldrm/exercises-dataset provides a machine-readable catalog where every exercise record explicitly declares its synergistic muscle groups. This structured data enables developers to build recommendation engines, prevent muscle imbalances, and analyze movement patterns across a multilingual corpus.

Understanding the Secondary Muscles Data Structure

The dataset treats secondary muscles as supporting actors to the primary target muscle. Each exercise entry includes a secondary_muscles field that catalogs additional muscle groups activated during the movement.

Schema Definition in exercises.schema.json

The formal structure for secondary muscles involved in exercises is defined in data/exercises.schema.json. According to the schema specification at lines 103-107, the secondary_muscles property is an array of strings designed to hold muscle names in English.

The schema mandates this field as required (lines 138-149), meaning every exercise record must include the key. However, the array itself may be empty when an exercise has no significant secondary recruitment, ensuring data consistency while accommodating isolation movements.

Data Implementation in exercises.json

The actual data resides in data/exercises.json, which contains 1,324 exercise objects across ten language translations. Each object follows the schema by including the secondary_muscles array.

For example, the "3/4 sit-up" entry demonstrates the field in practice:

{
  "id": "3_4_sit_up",
  "name": "3/4 sit-up",
  "primary_muscles": ["abdominals"],
  "secondary_muscles": ["hip flexors", "lower back"],
  "level": "beginner"
}

This pattern repeats acrosscompound movements like bench presses (triceps, shoulders) and squats (glutes, hamstrings), creating a queryable graph of muscle relationships.

Practical Applications of Secondary Muscle Data

Developers leverage the secondary muscles involved in exercises field to power several fitness technology use cases:

• Exercise Recommendation Engines – Match user goals with both primary and synergistic muscles to suggest comprehensive workout routines.
• Workout-Plan Generators – Balance secondary-muscle load across training sessions to prevent overtraining supporting muscle groups.
• Analytics and Research – Aggregate counts of how often particular secondary muscles appear (for example, determining that "triceps" frequently appears in pushing movements).

How to Query Secondary Muscles in the Dataset

You can programmatically extract and analyze secondary muscles involved in exercises using the following patterns.

Python: Load and Analyze Secondary Muscles

import json
from collections import Counter

# Load the full exercise list

with open("data/exercises.json", "r", encoding="utf-8") as f:
    exercises = json.load(f)

# Gather every secondary muscle name

all_secondary = [muscle
                 for ex in exercises
                 for muscle in ex.get("secondary_muscles", [])]

# Count how many times each appears

freq = Counter(all_secondary)

print("Top secondary muscles:")
for muscle, cnt in freq.most_common(10):
    print(f"{muscle}: {cnt} exercises")

JavaScript (Node.js): Filter by Specific Muscles

const exercises = require("./data/exercises.json");

// Find all exercises where "triceps" is listed as a secondary muscle
const tricepsWork = exercises.filter(
  ex => ex.secondary_muscles && ex.secondary_muscles.includes("triceps")
);

console.log(`Found ${tricepsWork.length} exercises with triceps as secondary muscle`);

SQL: Querying in a Relational Database

-- Assuming a table `exercises` with a JSON column `data`
SELECT
  json_array_elements_text(data->'secondary_muscles') AS secondary_muscle,
  COUNT(*) AS usage_count
FROM exercises
GROUP BY secondary_muscle
ORDER BY usage_count DESC
LIMIT 10;

Summary

• The secondary_muscles field in data/exercises.json is a required array of strings listing supporting muscles for each exercise.
• The JSON Schema in data/exercises.schema.json formally defines this structure and mandates its presence, though empty arrays are valid for isolation exercises.
• The dataset covers 1,324 exercises with multilingual support, making it suitable for global fitness applications.
• Secondary muscle data enables intelligent workout balancing, recommendation algorithms, and biomechanical analysis.
• All code examples use standard library functions to parse the raw JSON without requiring specialized dependencies.

Frequently Asked Questions

What does the secondary_muscles field contain?

The secondary_muscles field contains an array of English strings representing muscle groups that assist the primary target during an exercise. For example, a squat might list "glutes" and "hamstrings" as secondary muscles while "quadriceps" serves as the primary target.

Is the secondary_muscles field mandatory for every exercise?

Yes. According to the schema definition in data/exercises.schema.json (lines 138-149), the secondary_muscles field is required for every record. However, if an exercise truly isolates a single muscle group, the field should contain an empty array [] rather than being omitted entirely.

How can I find exercises targeting a specific secondary muscle?

You can filter the data/exercises.json array by checking if the target muscle string exists within the secondary_muscles array. Both the Python and JavaScript examples above demonstrate how to perform this filtering operation efficiently using list comprehensions or the filter() method.

What are common secondary muscles across the dataset?

Based on the distribution of 1,324 exercises, frequently appearing secondary muscles include triceps (in pushing movements), deltoids (in upper body compound exercises), and hamstrings (in lower body pulling movements). The Python Counter example above shows how to generate exact frequency statistics for your analysis.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}