# Fetching Single Items

Fetch a specific workout, plan, or exercise by ID or title.

**By ID:** Use the unique document ID for exact match
**By Title:** Use the content title (case-insensitive, returns first match)

**Fetch by ID**

_Swift (iOS)_
```swift
// Fetch a specific workout by ID
Task {
    let result = await kinestex.fetchWorkout(id: "9zE1kzOzpU5d5dAJrPOY")

    switch result {
    case .success(let workout):
        print("Workout: \(workout.title)")
        print("Duration: \(workout.totalMinutes ?? 0) minutes")
        print("Calories: \(workout.totalCalories ?? 0)")
        print("Exercises: \(workout.sequence.count)")

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

// Fetch a specific exercise by ID
Task {
    let result = await kinestex.fetchExercise(id: "jz73VFlUyZ9nyd64OjRb")

    switch result {
    case .success(let exercise):
        print("Exercise: \(exercise.title)")
        print("Model ID: \(exercise.modelId)")

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

// Fetch a specific plan by ID
Task {
    let result = await kinestex.fetchPlan(id: "22B3qRU2r75hVXHgGiGx")

    switch result {
    case .success(let plan):
        print("Plan: \(plan.title)")

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

_Kotlin (Android)_
```kotlin
// Fetch a specific workout by ID
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        KinesteXSDK.api.fetchAPIContentData(
            contentType = ContentType.WORKOUT,
            id = "9zE1kzOzpU5d5dAJrPOY"
        )
    }

    when (result) {
        is APIContentResult.Workout -> {
            val workout = result.workout
            Log.d("API", "Workout: ${workout.title}")
            Log.d("API", "Duration: ${workout.totalMinutes} minutes")
        }
        is APIContentResult.Error -> {
            Log.e("API", "Error: ${result.message}")
        }
        else -> {}
    }
}

// Fetch a specific exercise by ID
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        KinesteXSDK.api.fetchAPIContentData(
            contentType = ContentType.EXERCISE,
            id = "jz73VFlUyZ9nyd64OjRb"
        )
    }

    when (result) {
        is APIContentResult.Exercise -> {
            val exercise = result.exercise
            Log.d("API", "Exercise: ${exercise.title}")
        }
        is APIContentResult.Error -> {
            Log.e("API", "Error: ${result.message}")
        }
        else -> {}
    }
}
```

_Flutter_
```dart
// Fetch a specific workout by ID
Future<void> fetchWorkoutById() async {
  final result = await KinesteXAIFramework.apiService.fetchContent(
    contentType: ContentType.workout,
    id: "9zE1kzOzpU5d5dAJrPOY",
  );

  switch (result) {
    case WorkoutResult(:final workout):
      print('Workout: ${workout.title}');
      print('Duration: ${workout.totalMinutes} minutes');
      print('Exercises: ${workout.sequence.length}');

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

    default:
      break;
  }
}

// Fetch a specific exercise by ID
Future<void> fetchExerciseById() async {
  final result = await KinesteXAIFramework.apiService.fetchContent(
    contentType: ContentType.exercise,
    id: "jz73VFlUyZ9nyd64OjRb",
  );

  switch (result) {
    case ExerciseResult(:final exercise):
      print('Exercise: ${exercise.title}');
      print('Model ID: ${exercise.modelId}');

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

    default:
      break;
  }
}
```

_React Native_
```jsx
// Fetch a specific workout by ID
const fetchWorkoutById = async (id: string): Promise<WorkoutModel> => {
  const response = await fetch(
    `${BASE_URL}/workouts/${id}`,
    { headers }
  );

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

  return response.json();
};

// Fetch a specific exercise by ID
const fetchExerciseById = async (id: string): Promise<ExerciseModel> => {
  const response = await fetch(
    `${BASE_URL}/exercises/${id}`,
    { headers }
  );

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

  return response.json();
};

// Fetch a specific plan by ID
const fetchPlanById = async (id: string): Promise<PlanModel> => {
  const response = await fetch(
    `${BASE_URL}/plans/${id}`,
    { headers }
  );

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

  return response.json();
};

// Usage
const workout = await fetchWorkoutById('9zE1kzOzpU5d5dAJrPOY');
const exercise = await fetchExerciseById('jz73VFlUyZ9nyd64OjRb');
const plan = await fetchPlanById('22B3qRU2r75hVXHgGiGx');
```

_HTML / JavaScript_
```html
// Fetch a specific workout by ID
async function fetchWorkoutById(id) {
  const response = await fetch(
    `${BASE_URL}/workouts/${id}`,
    { headers }
  );

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

  return response.json();
}

// Fetch a specific exercise by ID
async function fetchExerciseById(id) {
  const response = await fetch(
    `${BASE_URL}/exercises/${id}`,
    { headers }
  );

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

  return response.json();
}

// Fetch a specific plan by ID
async function fetchPlanById(id) {
  const response = await fetch(
    `${BASE_URL}/plans/${id}`,
    { headers }
  );

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

  return response.json();
}

// Usage
fetchWorkoutById('9zE1kzOzpU5d5dAJrPOY').then(workout => console.log(workout));
```

_React (TypeScript)_
```tsx
// Fetch a specific workout by ID
const fetchWorkoutById = async (id: string): Promise<WorkoutModel> => {
  const response = await fetch(
    `${BASE_URL}/workouts/${id}`,
    { headers }
  );

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

  return response.json();
};

// Fetch a specific exercise by ID
const fetchExerciseById = async (id: string): Promise<ExerciseModel> => {
  const response = await fetch(
    `${BASE_URL}/exercises/${id}`,
    { headers }
  );

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

  return response.json();
};

// Fetch a specific plan by ID
const fetchPlanById = async (id: string): Promise<PlanModel> => {
  const response = await fetch(
    `${BASE_URL}/plans/${id}`,
    { headers }
  );

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

  return response.json();
};

// Usage
const workout = await fetchWorkoutById('9zE1kzOzpU5d5dAJrPOY');
console.log(`Workout: ${workout.title}`);
```

**Fetch by Title**

_Swift (iOS)_
```swift
// Fetch content by title (returns first match)
Task {
    let result = await kinestex.fetchContent(
        contentType: .workout,
        title: "Fitness Lite"
    )

    switch result {
    case .workout(let workout):
        print("Found workout: \(workout.title)")

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

    default:
        print("Unexpected result type")
    }
}
```

_Kotlin (Android)_
```kotlin
// Fetch content by title (returns first match)
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        KinesteXSDK.api.fetchAPIContentData(
            contentType = ContentType.WORKOUT,
            title = "Fitness Lite"
        )
    }

    when (result) {
        is APIContentResult.Workout -> {
            Log.d("API", "Found workout: ${result.workout.title}")
        }
        is APIContentResult.Error -> {
            Log.e("API", "Error: ${result.message}")
        }
        else -> {}
    }
}
```

_Flutter_
```dart
// Fetch content by title (returns first match)
Future<void> fetchByTitle() async {
  final result = await KinesteXAIFramework.apiService.fetchContent(
    contentType: ContentType.workout,
    title: "Fitness Lite",
  );

  switch (result) {
    case WorkoutResult(:final workout):
      print('Found workout: ${workout.title}');

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

    default:
      break;
  }
}
```

_React Native_
```jsx
// Fetch content by title (returns first match)
const fetchWorkoutByTitle = async (title: string): Promise<WorkoutModel> => {
  const response = await fetch(
    `${BASE_URL}/workouts/${encodeURIComponent(title)}`,
    { headers }
  );

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

  return response.json();
};

// Usage
const workout = await fetchWorkoutByTitle('Fitness Lite');
```

_HTML / JavaScript_
```html
// Fetch content by title (returns first match)
async function fetchWorkoutByTitle(title) {
  const response = await fetch(
    `${BASE_URL}/workouts/${encodeURIComponent(title)}`,
    { headers }
  );

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

  return response.json();
}

// Usage
fetchWorkoutByTitle('Fitness Lite').then(workout => console.log(workout));
```

_React (TypeScript)_
```tsx
// Fetch content by title (returns first match)
const fetchWorkoutByTitle = async (title: string): Promise<WorkoutModel> => {
  const response = await fetch(
    `${BASE_URL}/workouts/${encodeURIComponent(title)}`,
    { headers }
  );

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

  return response.json();
};

// Usage
const workout = await fetchWorkoutByTitle('Fitness Lite');
```

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