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

> Explore the Exercises Dataset to discover secondary muscles used in various exercises. Learn about the dataset schema, structure, and how to query for supporting muscle groups in this comprehensive guide.

- Repository: [Hasan Emir Yıldırım/exercises-dataset](https://github.com/hasaneyldrm/exercises-dataset)
- Tags: api-reference
- Published: 2026-07-29

---

**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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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:

```json
{
  "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

```python
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

```javascript
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

```sql
-- 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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json) is a required array of strings listing supporting muscles for each exercise.
- The JSON Schema in [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/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.