The MediaPipe Pose Landmarker task lets you detect landmarks of human bodies in an image or
video. You can use this task to identify key body locations, analyze posture,
and categorize movements. This task uses machine learning (ML) models that
work with single images or video. The task outputs body pose landmarks in image
coordinates and in 3-dimensional world coordinates.
[Open in Web Demos](https://google-ai-edge.github.io/mediapipe-samples-web/#/vision/pose_landmarker)[Edit in StackBlitz](https://stackblitz.com/github/google-ai-edge/mediapipe-samples-web?file=src/tasks/pose-landmarker.ts)
## Quickstart
Install the SDK for your platform,
[prepare input data](https://developers.google.com/edge/mediapipe/solutions/prepare_data.md.txt#vision), choose a
running mode, and run inference.
### Web
npm`npm install @mediapipe/tasks-vision`[Web demo](https://google-ai-edge.github.io/mediapipe-samples-web/#/vision/pose_landmarker)·[Edit in StackBlitz](https://stackblitz.com/github/google-ai-edge/mediapipe-samples-web?file=src/tasks/pose-landmarker.ts)·[Setup guide](https://developers.google.com/edge/mediapipe/solutions/setup_web.md.txt)
#### Image
`IMAGE`Stateless · single frameSynchronous call on independent still images. Resets temporal tracking state on every call.
```typescript
import { FilesetResolver, PoseLandmarker } from "@mediapipe/tasks-vision";
const vision = await FilesetResolver.forVisionTasks(
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm"
);
const poseLandmarker = await PoseLandmarker.createFromOptions(vision, {
baseOptions: { modelAssetPath: "pose_landmarker_lite.task", delegate: "GPU" },
runningMode: "IMAGE",
numPoses: 1,
});
// Synchronous single-frame call (stateless across images)
const image = document.getElementById("image") as HTMLImageElement;
const result = poseLandmarker.detect(image);
```
#### Video
`VIDEO`Every frame · no dropsSynchronous tracking across decoded video frames with monotonic timestamps. Processes every frame in order and never drops frames.
```typescript
import { FilesetResolver, PoseLandmarker } from "@mediapipe/tasks-vision";
const vision = await FilesetResolver.forVisionTasks(
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm"
);
const poseLandmarker = await PoseLandmarker.createFromOptions(vision, {
baseOptions: { modelAssetPath: "pose_landmarker_lite.task", delegate: "GPU" },
runningMode: "VIDEO",
numPoses: 1,
});
// Synchronous across decoded frames with monotonic timestamps (never drops frames)
for (const { frame, timestampMs } of decodedVideoFrames) {
const result = poseLandmarker.detectForVideo(frame, timestampMs);
}
```
#### Livestream
`VIDEO + rAF`Live camera · latest frameWeb tasks run synchronously---pair `runningMode: "VIDEO"` with `requestAnimationFrame` so each paint inspects only the latest camera frame (skipping intermediate frames when busy).
```typescript
import { FilesetResolver, PoseLandmarker } from "@mediapipe/tasks-vision";
const vision = await FilesetResolver.forVisionTasks(
"https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm"
);
// On Web, live camera loops pair runningMode: "VIDEO" with requestAnimationFrame
const poseLandmarker = await PoseLandmarker.createFromOptions(vision, {
baseOptions: { modelAssetPath: "pose_landmarker_lite.task", delegate: "GPU" },
runningMode: "VIDEO",
numPoses: 1,
});
const video = document.getElementById("webcam") as HTMLVideoElement;
video.srcObject = await navigator.mediaDevices.getUserMedia({ video: true });
await video.play();
let lastVideoTime = -1;
function renderLoop() {
if (video.readyState >= 2 && video.currentTime !== lastVideoTime) {
lastVideoTime = video.currentTime;
const result = poseLandmarker.detectForVideo(video, performance.now());
console.log(result.landmarks, result.worldLandmarks);
}
requestAnimationFrame(renderLoop);
}
renderLoop();
```
### Android (Kotlin)
Gradle`implementation("com.google.mediapipe:tasks-vision:latest.release")`[Sample code](https://github.com/google-ai-edge/mediapipe-samples/tree/main/examples/pose_landmarker/android)·[Setup guide](https://developers.google.com/edge/mediapipe/solutions/setup_android.md.txt)
#### Image
`IMAGE`Stateless · single frameSynchronous call on independent still images. Resets temporal tracking state on every call.
```kotlin
import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage
import com.google.mediapipe.tasks.core.BaseOptions
import com.google.mediapipe.tasks.vision.core.RunningMode
import com.google.mediapipe.tasks.vision.poselandmarker.PoseLandmarker
val baseOptions = BaseOptions.builder()
.setModelAssetPath("pose_landmarker_lite.task")
.build()
val options = PoseLandmarker.PoseLandmarkerOptions.builder()
.setBaseOptions(baseOptions)
.setRunningMode(RunningMode.IMAGE)
.setNumPoses(1)
.build()
val poseLandmarker = PoseLandmarker.createFromOptions(context, options)
// Synchronous single-image call (no temporal tracking across calls)
val mpImage = BitmapImageBuilder(bitmap).build()
val result = poseLandmarker.detect(mpImage)
```
#### Video
`VIDEO`Every frame · no dropsSynchronous tracking across decoded video frames with monotonic timestamps. Processes every frame in order and never drops frames.
```kotlin
import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage
import com.google.mediapipe.tasks.core.BaseOptions
import com.google.mediapipe.tasks.vision.core.RunningMode
import com.google.mediapipe.tasks.vision.poselandmarker.PoseLandmarker
val baseOptions = BaseOptions.builder()
.setModelAssetPath("pose_landmarker_lite.task")
.build()
val options = PoseLandmarker.PoseLandmarkerOptions.builder()
.setBaseOptions(baseOptions)
.setRunningMode(RunningMode.VIDEO)
.setNumPoses(1)
.build()
val poseLandmarker = PoseLandmarker.createFromOptions(context, options)
// Synchronous: processes every frame in order with monotonic timestamps (no frame drops)
val mpImage = BitmapImageBuilder(frameBitmap).build()
val result = poseLandmarker.detectForVideo(mpImage, frameTimestampMs)
```
#### Livestream
`LIVE_STREAM`Async · drops frames when busyAsynchronous camera pipeline with a result callback. Automatically drops incoming frames when busy so results stay current with low latency.
```kotlin
import android.os.SystemClock
import android.util.Log
import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage
import com.google.mediapipe.tasks.core.BaseOptions
import com.google.mediapipe.tasks.vision.core.RunningMode
import com.google.mediapipe.tasks.vision.poselandmarker.PoseLandmarker
val baseOptions = BaseOptions.builder()
.setModelAssetPath("pose_landmarker_lite.task")
.build()
val options = PoseLandmarker.PoseLandmarkerOptions.builder()
.setBaseOptions(baseOptions)
.setRunningMode(RunningMode.LIVE_STREAM)
.setNumPoses(1)
.setResultListener { result, _ -> val poses = result.landmarks() }
.setErrorListener { error -> Log.e("MediaPipe", error.message.orEmpty()) }
.build()
val poseLandmarker = PoseLandmarker.createFromOptions(context, options)
// Async: automatically drops incoming camera frames when busy so results stay current
poseLandmarker.detectAsync(mpImage, SystemClock.uptimeMillis())
```
### Android (Java)
Gradle`implementation 'com.google.mediapipe:tasks-vision:latest.release'`[Sample code](https://github.com/google-ai-edge/mediapipe-samples/tree/main/examples/pose_landmarker/android)·[Setup guide](https://developers.google.com/edge/mediapipe/solutions/setup_android.md.txt)
#### Image
`IMAGE`Stateless · single frameSynchronous call on independent still images. Resets temporal tracking state on every call.
```java
import com.google.mediapipe.framework.image.BitmapImageBuilder;
import com.google.mediapipe.framework.image.MPImage;
import com.google.mediapipe.tasks.core.BaseOptions;
import com.google.mediapipe.tasks.vision.core.RunningMode;
import com.google.mediapipe.tasks.vision.poselandmarker.PoseLandmarker;
import com.google.mediapipe.tasks.vision.poselandmarker.PoseLandmarkerResult;
BaseOptions baseOptions = BaseOptions.builder()
.setModelAssetPath("pose_landmarker_lite.task")
.build();
PoseLandmarker.PoseLandmarkerOptions options = PoseLandmarker.PoseLandmarkerOptions.builder()
.setBaseOptions(baseOptions)
.setRunningMode(RunningMode.IMAGE)
.setNumPoses(1)
.build();
PoseLandmarker poseLandmarker = PoseLandmarker.createFromOptions(context, options);
// Synchronous single-image call (no temporal tracking across calls)
MPImage mpImage = new BitmapImageBuilder(bitmap).build();
PoseLandmarkerResult result = poseLandmarker.detect(mpImage);
```
#### Video
`VIDEO`Every frame · no dropsSynchronous tracking across decoded video frames with monotonic timestamps. Processes every frame in order and never drops frames.
```java
import com.google.mediapipe.framework.image.BitmapImageBuilder;
import com.google.mediapipe.framework.image.MPImage;
import com.google.mediapipe.tasks.core.BaseOptions;
import com.google.mediapipe.tasks.vision.core.RunningMode;
import com.google.mediapipe.tasks.vision.poselandmarker.PoseLandmarker;
import com.google.mediapipe.tasks.vision.poselandmarker.PoseLandmarkerResult;
BaseOptions baseOptions = BaseOptions.builder()
.setModelAssetPath("pose_landmarker_lite.task")
.build();
PoseLandmarker.PoseLandmarkerOptions options = PoseLandmarker.PoseLandmarkerOptions.builder()
.setBaseOptions(baseOptions)
.setRunningMode(RunningMode.VIDEO)
.setNumPoses(1)
.build();
PoseLandmarker poseLandmarker = PoseLandmarker.createFromOptions(context, options);
// Synchronous: processes every frame in order with monotonic timestamps (no frame drops)
MPImage mpImage = new BitmapImageBuilder(frameBitmap).build();
PoseLandmarkerResult result = poseLandmarker.detectForVideo(mpImage, frameTimestampMs);
```
#### Livestream
`LIVE_STREAM`Async · drops frames when busyAsynchronous camera pipeline with a result callback. Automatically drops incoming frames when busy so results stay current with low latency.
```java
import android.os.SystemClock;
import android.util.Log;
import com.google.mediapipe.framework.image.BitmapImageBuilder;
import com.google.mediapipe.framework.image.MPImage;
import com.google.mediapipe.tasks.core.BaseOptions;
import com.google.mediapipe.tasks.vision.core.RunningMode;
import com.google.mediapipe.tasks.vision.poselandmarker.PoseLandmarker;
BaseOptions baseOptions = BaseOptions.builder()
.setModelAssetPath("pose_landmarker_lite.task")
.build();
PoseLandmarker.PoseLandmarkerOptions options = PoseLandmarker.PoseLandmarkerOptions.builder()
.setBaseOptions(baseOptions)
.setRunningMode(RunningMode.LIVE_STREAM)
.setNumPoses(1)
.setResultListener((result, inputImage) -> { var poses = result.landmarks(); })
.setErrorListener(error -> Log.e("MediaPipe", String.valueOf(error.getMessage())))
.build();
PoseLandmarker poseLandmarker = PoseLandmarker.createFromOptions(context, options);
// Async: automatically drops incoming camera frames when busy so results stay current
poseLandmarker.detectAsync(mpImage, SystemClock.uptimeMillis());
```
### iOS
SwiftPM`https://github.com/google-ai-edge/mediapipe → MediaPipeTasksVision`[Package.swift](https://developers.google.com/edge/mediapipe/solutions/setup_ios.md.txt#package_swift)·[Sample code](https://github.com/google-ai-edge/mediapipe-samples/tree/main/examples/pose_landmarker/ios)·[Setup guide](https://developers.google.com/edge/mediapipe/solutions/setup_ios.md.txt)
#### Image
`IMAGE`Stateless · single frameSynchronous call on independent still images. Resets temporal tracking state on every call.
```swift
import Foundation
import MediaPipeTasksVision
guard let modelPath = Bundle.main.path(forResource: "pose_landmarker_lite", ofType: "task") else { return }
let options = PoseLandmarkerOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .image
options.numPoses = 1
let poseLandmarker = try PoseLandmarker(options: options)
// Synchronous single-image call (stateless across images)
let mpImage = try MPImage(uiImage: image)
let result = try poseLandmarker.detect(image: mpImage)
```
#### Video
`VIDEO`Every frame · no dropsSynchronous tracking across decoded video frames with monotonic timestamps. Processes every frame in order and never drops frames.
```swift
import Foundation
import MediaPipeTasksVision
guard let modelPath = Bundle.main.path(forResource: "pose_landmarker_lite", ofType: "task") else { return }
let options = PoseLandmarkerOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .video
options.numPoses = 1
let poseLandmarker = try PoseLandmarker(options: options)
// Synchronous: processes every frame in order with monotonic timestamps (no frame drops)
let mpImage = try MPImage(pixelBuffer: pixelBuffer)
let result = try poseLandmarker.detect(videoFrame: mpImage, timestampInMilliseconds: timestampMs)
```
#### Livestream
`LIVE_STREAM`Async · drops frames when busyAsynchronous camera pipeline with a result callback. Automatically drops incoming frames when busy so results stay current with low latency.
```swift
import Foundation
import MediaPipeTasksVision
final class PoseLandmarkerStreamService: NSObject {
private var poseLandmarker: PoseLandmarker?
func setUp() throws {
guard let modelPath = Bundle.main.path(
forResource: "pose_landmarker_lite",
ofType: "task"
) else { return }
let options = PoseLandmarkerOptions()
options.baseOptions.modelAssetPath = modelPath
options.runningMode = .liveStream
options.numPoses = 1
options.poseLandmarkerLiveStreamDelegate = self
poseLandmarker = try PoseLandmarker(options: options)
}
func detectAsync(mpImage: MPImage, timestampMs: Int) throws {
// Async: automatically drops incoming camera frames when busy so results stay current
try poseLandmarker?.detectAsync(image: mpImage, timestampInMilliseconds: timestampMs)
}
}
extension PoseLandmarkerStreamService: PoseLandmarkerLiveStreamDelegate {
func poseLandmarker(
_ poseLandmarker: PoseLandmarker,
didFinishDetection result: PoseLandmarkerResult?,
timestampInMilliseconds: Int,
error: (any Error)?
) {
guard let result else { return }
DispatchQueue.main.async {
let poses = result.landmarks
}
}
}
```
### Python
pip`pip install mediapipe`[Sample code](https://colab.research.google.com/github/google-ai-edge/mediapipe-samples/blob/main/examples/pose_landmarker/python/%5BMediaPipe_Python_Tasks%5D_Pose_Landmarker.ipynb)·[Setup guide](https://developers.google.com/edge/mediapipe/solutions/setup_python.md.txt)
#### Image
`IMAGE`Stateless · single frameSynchronous call on independent still images. Resets temporal tracking state on every call.
```python
import mediapipe as mp
BaseOptions = mp.tasks.BaseOptions
PoseLandmarker = mp.tasks.vision.PoseLandmarker
PoseLandmarkerOptions = mp.tasks.vision.PoseLandmarkerOptions
VisionRunningMode = mp.tasks.vision.RunningMode
options = PoseLandmarkerOptions(
base_options=BaseOptions(model_asset_path="pose_landmarker_lite.task"),
running_mode=VisionRunningMode.IMAGE,
num_poses=1,
)
with PoseLandmarker.create_from_options(options) as landmarker:
# Synchronous single-image call (stateless across images)
mp_image = mp.Image.create_from_file("input.jpg")
result = landmarker.detect(mp_image)
```
#### Video
`VIDEO`Every frame · no dropsSynchronous tracking across decoded video frames with monotonic timestamps. Processes every frame in order and never drops frames.
```python
import mediapipe as mp
BaseOptions = mp.tasks.BaseOptions
PoseLandmarker = mp.tasks.vision.PoseLandmarker
PoseLandmarkerOptions = mp.tasks.vision.PoseLandmarkerOptions
VisionRunningMode = mp.tasks.vision.RunningMode
options = PoseLandmarkerOptions(
base_options=BaseOptions(model_asset_path="pose_landmarker_lite.task"),
running_mode=VisionRunningMode.VIDEO,
num_poses=1,
)
with PoseLandmarker.create_from_options(options) as landmarker:
# Synchronous: processes every frame in order with monotonic timestamps (no frame drops)
for mp_image, timestamp_ms in decoded_video_frames:
result = landmarker.detect_for_video(mp_image, timestamp_ms)
```
#### Livestream
`LIVE_STREAM`Async · drops frames when busyAsynchronous camera pipeline with a result callback. Automatically drops incoming frames when busy so results stay current with low latency.
```python
import mediapipe as mp
BaseOptions = mp.tasks.BaseOptions
PoseLandmarker = mp.tasks.vision.PoseLandmarker
PoseLandmarkerOptions = mp.tasks.vision.PoseLandmarkerOptions
VisionRunningMode = mp.tasks.vision.RunningMode
def on_result(result, output_image: mp.Image, timestamp_ms: int):
print(f"Detected {len(result.pose_landmarks)} pose(s) at {timestamp_ms} ms")
options = PoseLandmarkerOptions(
base_options=BaseOptions(model_asset_path="pose_landmarker_lite.task"),
running_mode=VisionRunningMode.LIVE_STREAM,
num_poses=1,
result_callback=on_result,
)
with PoseLandmarker.create_from_options(options) as landmarker:
# Async: automatically drops incoming camera frames when busy so results stay current
mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_frame)
landmarker.detect_async(mp_image, timestamp_ms)
```
### Flutter
pub`flutter pub add mediapipe_vision`[Live gallery](https://google.github.io/flutter-mediapipe/)·[Sample code](https://github.com/google/flutter-mediapipe/tree/main/samples/vision/pose_landmarker)·[Setup guide](https://developers.google.com/edge/mediapipe/solutions/setup_flutter.md.txt)
#### Image
`RunningMode.image`Stateless · single frameOne call per independent still image. No tracking state carries over between calls.
```dart
import 'package:mediapipe_vision/mediapipe_vision.dart';
Future findPoses(VisionImage image) async {
final landmarker = await PoseLandmarker.create(
PoseLandmarkerOptions(model: VisionModels.poseLandmarker),
);
try {
final result = await landmarker.detect(image);
for (final pose in result.poseLandmarks) {
final nose = pose.first;
print('Nose at ${nose.x}, ${nose.y}, visibility ${nose.visibility}');
}
} finally {
await landmarker.dispose();
}
}
```
#### Video
`RunningMode.video`Every frame · no dropsTracking across decoded video frames with strictly increasing timestamps. Processes every frame in order and never drops frames.
```dart
import 'dart:typed_data';
import 'package:mediapipe_vision/mediapipe_vision.dart';
typedef Frame = ({Uint8List rgba, int width, int height, int milliseconds});
Future findPosesInVideo(Stream frames) async {
final landmarker = await PoseLandmarker.create(
PoseLandmarkerOptions(
model: VisionModels.poseLandmarker,
runningMode: RunningMode.video,
),
);
try {
await for (final frame in frames) {
final result = await landmarker.detectForVideo(
VisionImage.fromPixels(
pixels: frame.rgba,
width: frame.width,
height: frame.height,
format: VisionPixelFormat.rgba,
),
timestampMilliseconds: frame.milliseconds,
);
final ms = result.timestampMilliseconds;
for (final pose in result.poseLandmarks) {
final nose = pose.first;
print('$ms ms: nose at ${nose.x}, ${nose.y}');
}
}
} finally {
await landmarker.dispose();
}
}
```
#### Livestream
`RunningMode.liveStream`Async · drops frames when busyEach call returns at once and results arrive on the task's `results` stream. One frame runs at a time; a newer frame replaces one that's waiting, so results stay current.
```dart
import 'dart:typed_data';
import 'package:mediapipe_vision/mediapipe_vision.dart';
typedef Frame = ({Uint8List rgba, int width, int height, int milliseconds});
Future findPosesLive(Stream frames) async {
final landmarker = await PoseLandmarker.create(
PoseLandmarkerOptions(
model: VisionModels.poseLandmarker,
runningMode: RunningMode.liveStream,
),
);
// Listen before the first frame, as Google requires a result listener.
final results = landmarker.results.listen((result) {
final ms = result.timestampMilliseconds;
for (final pose in result.poseLandmarks) {
final nose = pose.first;
print('$ms ms: nose at ${nose.x}, ${nose.y}');
}
});
try {
await for (final frame in frames) {
landmarker.detectAsync(
VisionImage.fromPixels(
pixels: frame.rgba,
width: frame.width,
height: frame.height,
format: VisionPixelFormat.rgba,
),
timestampMilliseconds: frame.milliseconds,
);
}
} finally {
// Runs the frame in flight and the waiting one, then closes results.
await landmarker.dispose();
await results.cancel();
print('${landmarker.droppedFrames} frames dropped');
}
}
```
On Web, you can use `DrawingUtils(ctx).drawConnectors(landmarks, PoseLandmarker.POSE_CONNECTIONS)` and `drawLandmarks(landmarks)` from `@mediapipe/tasks-vision` to render pose skeletons on an HTML `