# Filtering & Parameters

Filter content by category and body parts for targeted results.

**Workout Categories:** Fitness, Rehabilitation

**Plan Categories:** Rehabilitation, Weight Management, Cardio, Strength

> **Important (Flutter, Swift & Kotlin SDKs):** When fetching plans, always provide the \`category\` parameter.

**Include KinesteX Library:**
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| include_kinestex | Bool | true | When set to \`true\`, results include workouts, plans, and exercises from the KinesteX workout library. Set to \`false\` to exclude KinesteX library content and only return your own custom content. |

**Filter by Translation Languages (REST API):**
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| translation_languages | String | — | Filter content by available translations. Pass a comma-separated list of language codes (e.g. \`es,fr\`) or repeat the parameter for each language (e.g. \`translation_languages=es&translation_languages=fr\`). Only content with translations in **all** specified languages is returned. Optional — omit to return all content regardless of translations. |

**Body Parts (BodyPart enum):**
| SDK Value (Swift) | SDK Value (Kotlin) | SDK Value (Flutter) | REST API Value |
|-------------------|--------------------|--------------------|----------------|
| .abs | ABS | BodyPart.abs | Abs |
| .biceps | BICEPS | BodyPart.biceps | Biceps |
| .calves | CALVES | BodyPart.calves | Calves |
| .chest | CHEST | BodyPart.chest | Chest |
| .externalOblique | EXTERNAL_OBLIQUE | BodyPart.externalOblique | External Oblique |
| .forearms | FOREARMS | BodyPart.forearms | Forearms |
| .glutes | GLUTES | BodyPart.glutes | Glutes |
| .hamstrings | HAMSTRINGS | BodyPart.hamstrings | Hamstrings |
| .lats | LATS | BodyPart.lats | Lats |
| .lowerBack | LOWER_BACK | BodyPart.lowerBack | Lower Back |
| .neck | NECK | BodyPart.neck | Neck |
| .quads | QUADS | BodyPart.quads | Quads |
| .shoulders | SHOULDERS | BodyPart.shoulders | Shoulders |
| .traps | TRAPS | BodyPart.traps | Traps |
| .triceps | TRICEPS | BodyPart.triceps | Triceps |
| .fullBody | FULL_BODY | BodyPart.fullBody | Full Body |

**Filter by Category and Body Parts**

_Swift (iOS)_
```swift
// Combine category and body parts filters
Task {
    let result = await kinestex.fetchContent(
        contentType: .workout,
        category: "Fitness",
        bodyParts: [.abs, .glutes, .quads],
        limit: 10
    )

    switch result {
    case .workouts(let response):
        let workouts = response.workouts
        print("Found \(workouts.count) workouts targeting abs, glutes, and quads")

    case .error(let message):
        print("Error: \(message)")

    default:
        break
    }
}
```

_Kotlin (Android)_
```kotlin
// Combine category and body parts filters
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        KinesteXSDK.api.fetchAPIContentData(
            contentType = ContentType.WORKOUT,
            category = "Fitness",
            bodyParts = listOf(BodyPart.ABS, BodyPart.GLUTES, BodyPart.QUADS),
            limit = 10
        )
    }

    when (result) {
        is APIContentResult.Workouts -> {
            val workouts = result.workouts
            Log.d("API", "Found ${workouts.size} workouts")
        }
        is APIContentResult.Error -> {
            Log.e("API", "Error: ${result.message}")
        }
        else -> {}
    }
}
```

_Flutter_
```dart
// Combine category and body parts filters
Future<void> fetchFilteredWorkouts() async {
  final result = await KinesteXAIFramework.apiService.fetchContent(
    contentType: ContentType.workout,
    category: "Fitness",
    bodyParts: [BodyPart.abs, BodyPart.glutes, BodyPart.quads],
    limit: 10,
  );

  switch (result) {
    case WorkoutsResult(:final response):
      print('Found ${response.workouts.length} workouts');

    case ErrorResult(:final message):
      print('Error: $message');

    default:
      break;
  }
}
```

_React Native_
```jsx
// Combine category and body parts filters
const fetchFilteredWorkouts = async (
  category: string,
  bodyParts: string[],
  limit: number = 10
): Promise<WorkoutModel[]> => {
  const params = new URLSearchParams({
    category,
    body_parts: bodyParts.join(','),
    limit: String(limit),
  });

  const response = await fetch(
    `${BASE_URL}/workouts?${params}`,
    { headers }
  );

  if (!response.ok) {
    throw new Error(`API Error: ${response.status}`);
  }

  const data = await response.json();
  return data.workouts;
};

// Usage
const workouts = await fetchFilteredWorkouts(
  'Fitness',
  ['Abs', 'Glutes', 'Quads'],
  10
);
```

_HTML / JavaScript_
```html
// Combine category and body parts filters
async function fetchFilteredWorkouts(category, bodyParts, limit = 10) {
  const params = new URLSearchParams({
    category,
    body_parts: bodyParts.join(','),
    limit: String(limit),
  });

  const response = await fetch(
    `${BASE_URL}/workouts?${params}`,
    { headers }
  );

  if (!response.ok) {
    throw new Error(`API Error: ${response.status}`);
  }

  const data = await response.json();
  return data.workouts;
}

// Usage
fetchFilteredWorkouts('Fitness', ['Abs', 'Glutes', 'Quads'], 10)
  .then(workouts => console.log(workouts));
```

_React (TypeScript)_
```tsx
// Combine category and body parts filters
const fetchFilteredWorkouts = async (
  category: string,
  bodyParts: string[],
  limit: number = 10
): Promise<WorkoutModel[]> => {
  const params = new URLSearchParams({
    category,
    body_parts: bodyParts.join(','),
    limit: String(limit),
  });

  const response = await fetch(
    `${BASE_URL}/workouts?${params}`,
    { headers }
  );

  if (!response.ok) {
    throw new Error(`API Error: ${response.status}`);
  }

  const data = await response.json();
  return data.workouts;
};

// Usage
const workouts = await fetchFilteredWorkouts(
  'Fitness',
  ['Abs', 'Glutes', 'Quads'],
  10
);
```

**Exclude KinesteX Library Content**

_Swift (iOS)_
```swift
// Fetch only your custom workouts (exclude KinesteX library)
Task {
    let result = await kinestex.fetchWorkouts(
        category: "Fitness",
        includeKinestex: false,  // Exclude KinesteX library content
        limit: 10
    )

    switch result {
    case .success(let response):
        let workouts = response.workouts
        print("Fetched \(workouts.count) custom workouts")

    case .failure(let error):
        print("Error: \(error.localizedDescription)")
    }
}
```

_Kotlin (Android)_
```kotlin
// Fetch only your custom workouts (exclude KinesteX library)
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        KinesteXSDK.api.fetchAPIContentData(
            contentType = ContentType.WORKOUT,
            category = "Fitness",
            includeKinestex = false,  // Exclude KinesteX library content
            limit = 10
        )
    }

    when (result) {
        is APIContentResult.Workouts -> {
            val workouts = result.workouts
            Log.d("API", "Fetched ${workouts.size} custom workouts")
        }
        is APIContentResult.Error -> {
            Log.e("API", "Error: ${result.message}")
        }
        else -> {}
    }
}
```

_Flutter_
```dart
// Fetch only your custom workouts (exclude KinesteX library)
Future<void> fetchCustomWorkouts() async {
  final result = await KinesteXAIFramework.apiService.fetchContent(
    contentType: ContentType.workout,
    category: "Fitness",
    includeKinestex: false,  // Exclude KinesteX library content
    limit: 10,
  );

  switch (result) {
    case WorkoutsResult(:final response):
      print('Fetched ${response.workouts.length} custom workouts');

    case ErrorResult(:final message):
      print('Error: $message');

    default:
      break;
  }
}
```

_React Native_
```jsx
// Fetch only your custom workouts (exclude KinesteX library)
const fetchCustomWorkouts = async (
  category: string,
  limit: number = 10
): Promise<WorkoutModel[]> => {
  const params = new URLSearchParams({
    category,
    include_kinestex: 'false',  // Exclude KinesteX library content
    limit: String(limit),
  });

  const response = await fetch(
    `${BASE_URL}/workouts?${params}`,
    { headers }
  );

  if (!response.ok) {
    throw new Error(`API Error: ${response.status}`);
  }

  const data = await response.json();
  return data.workouts;
};

// Usage - returns only your custom content
const customWorkouts = await fetchCustomWorkouts('Fitness', 10);
```

_HTML / JavaScript_
```html
// Fetch only your custom workouts (exclude KinesteX library)
async function fetchCustomWorkouts(category, limit = 10) {
  const params = new URLSearchParams({
    category,
    include_kinestex: 'false',  // Exclude KinesteX library content
    limit: String(limit),
  });

  const response = await fetch(
    `${BASE_URL}/workouts?${params}`,
    { headers }
  );

  if (!response.ok) {
    throw new Error(`API Error: ${response.status}`);
  }

  const data = await response.json();
  return data.workouts;
}

// Usage - returns only your custom content
fetchCustomWorkouts('Fitness', 10)
  .then(workouts => console.log(workouts));
```

_React (TypeScript)_
```tsx
// Fetch only your custom workouts (exclude KinesteX library)
const fetchCustomWorkouts = async (
  category: string,
  limit: number = 10
): Promise<WorkoutModel[]> => {
  const params = new URLSearchParams({
    category,
    include_kinestex: 'false',  // Exclude KinesteX library content
    limit: String(limit),
  });

  const response = await fetch(
    `${BASE_URL}/workouts?${params}`,
    { headers }
  );

  if (!response.ok) {
    throw new Error(`API Error: ${response.status}`);
  }

  const data = await response.json();
  return data.workouts;
};

// Usage - returns only your custom content
const customWorkouts = await fetchCustomWorkouts('Fitness', 10);
```

---
Source: https://kinestex.com/docs/content-api/content-api-filtering · Index: https://kinestex.com/llms.txt