# Primary Muscle Targets for Exercises in the hasaneyldrm/exercises-dataset

> Discover primary muscle targets for exercises in the hasaneyldrm/exercises-dataset. Easily find the main muscle emphasis for each movement in the exercises json file.

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

---

**The primary muscle target for each exercise is stored in the `target` field of every record in the [`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json) file, representing the main muscle the movement is designed to emphasize.**

The **hasaneyldrm/exercises-dataset** repository contains a structured collection of 1,324 exercise records, each documenting which muscle groups are emphasized during the movement. Understanding how to access and interpret the primary muscle targets is essential for building fitness applications, filtering workout routines, or analyzing exercise distributions.

## Understanding the Dataset Schema

Each exercise object in the dataset defines three distinct fields related to muscle targeting:

- **`target`** — The **primary muscle** that the exercise emphasizes (e.g., "abs", "biceps", "glutes")
- **`muscle_group`** — The primary synergist or supporting muscle group, often representing a larger anatomical region (e.g., "hip flexors")
- **`secondary_muscles`** — An array of additional muscles that act as helpers or stabilizers during the movement

In the [`README.md`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/README.md) file at lines 70-72, the schema documentation explicitly defines `target` as the primary muscle field. A concrete example appears in the sample record for **"3/4 sit-up"** where the `target` field is set to **"abs"**, the `muscle_group` is **"hip flexors"**, and the `secondary_muscles` array contains `["hip flexors", "lower back"]` according to the documentation at lines 24-30.

## How to Extract Primary Muscle Targets

To retrieve the primary muscle targets across the entire collection, read the `target` property from each JSON object in [`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json). Below are practical implementations in several languages.

### Python (Standard Library)

Use the built-in `json` module and `collections.Counter` to analyze frequency distributions:

```python
import json
from collections import Counter

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

# Count how many times each primary target appears

target_counts = Counter(ex["target"] for ex in exercises)

print("Top 10 primary muscle targets:")
for muscle, count in target_counts.most_common(10):
    print(f"{muscle}: {count}")

```

### Python (Pandas)

For data science workflows, load the JSON into a DataFrame to leverage vectorized operations:

```python
import json
import pandas as pd

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

df = pd.DataFrame(data)

print(df["target"].value_counts().head(10))

```

### JavaScript and Node.js

In Node.js environments, require the JSON file and use array methods to extract unique targets:

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

// Get a Set of unique primary targets
const targets = new Set(exercises.map(e => e.target));

console.log("Unique primary muscle targets:", [...targets].sort());

// Frequency count
const counts = exercises.reduce((acc, ex) => {
  acc[ex.target] = (acc[ex.target] || 0) + 1;
  return acc;
}, {});

console.log("Top 10 targets:", Object.entries(counts)
  .sort((a, b) => b[1] - a[1])
  .slice(0, 10));

```

### TypeScript

For type-safe access, define an interface matching the [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json) structure:

```typescript
interface Exercise {
  id: string;
  name: string;
  category: string;
  body_part: string;
  equipment: string;
  instructions: Record<string, string>;
  instruction_steps: Record<string, string[]>;
  muscle_group: string;
  secondary_muscles: string[];
  target: string;               // ← primary muscle target
  media_id: string;
  image: string;
  gif_url: string;
  attribution: string;
  created_at: string;
}

import exercises from "./data/exercises.json";
const data = exercises as Exercise[];

// Unique targets
const uniqueTargets = Array.from(new Set(data.map(e => e.target))).sort();
console.log("Primary muscle targets:", uniqueTargets);

// Frequency
const freq = data.reduce<Record<string, number>>((acc, ex) => {
  acc[ex.target] = (acc[ex.target] ?? 0) + 1;
  return acc;
}, {});
console.log("Most common targets:", Object.entries(freq)
  .sort((a, b) => b[1] - a[1])
  .slice(0, 10));

```

## Key Files and Schema Validation

The repository structure provides three critical resources for working with primary muscle targets:

- **[`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json)** — The main data file containing the array of 1,324 exercise objects, each with the `target` field
- **[`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json)** — JSON Schema defining the required structure and data types, including validation for the `target` property
- **[`README.md`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/README.md)** — Human-readable documentation describing the relationship between `target`, `muscle_group`, and `secondary_muscles` fields

According to the schema definition in [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json), the `target` field is required for every exercise record, ensuring consistent data availability across the dataset.

## Summary

- The **primary muscle target** for each exercise is stored in the **`target`** field of [`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json)
- Each record distinguishes between primary muscles (`target`), supporting groups (`muscle_group`), and stabilizers (`secondary_muscles`)
- The dataset contains 1,324 exercises with consistent schema validation ensuring every entry has a defined primary target
- Extract targets using standard JSON parsing in Python, JavaScript, or TypeScript by accessing the `.target` property on each exercise object

## Frequently Asked Questions

### What is the difference between `target` and `muscle_group` in the dataset?

The **`target`** field specifies the single primary muscle that receives the main load during the exercise (e.g., "abs"), while **`muscle_group`** indicates the broader anatomical region or synergist muscles that support the movement (e.g., "hip flexors"). This distinction allows applications to filter exercises by both specific muscles and general body regions.

### How can I validate that an exercise record contains a primary muscle target?

Each exercise in [`data/exercises.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.json) must conform to [`data/exercises.schema.json`](https://github.com/hasaneyldrm/exercises-dataset/blob/main/data/exercises.schema.json), which defines the `target` field as a required string property. When parsing the dataset, verify that `ex.target` exists and contains a non-empty string to ensure compliance with the schema.

### Are secondary muscles also considered primary targets for exercises?

No, **secondary muscles** function as helpers or stabilizers rather than primary targets. According to the schema documentation in the README, the `secondary_muscles` array lists muscles that assist the movement but do not receive the main emphasis, distinguishing them from the single primary target stored in the `target` field.

### Can I filter exercises by multiple primary muscle targets simultaneously?

Yes, since `target` is a string value on each exercise object, you can filter the dataset by creating a set or array of desired targets and selecting exercises where `ex.target` matches any value in your filter list. The dataset structure supports efficient filtering because every record contains the primary target as a top-level property.