diff --git a/build.gradle b/build.gradle
index 456ad072..875676ca 100644
--- a/build.gradle
+++ b/build.gradle
@@ -62,12 +62,14 @@ ext {
   isPublished = { project ->
     isJavaProject(project) &&
         project.name != 'methanol-blackbox' &&
-        project.name != 'methanol-samples'
+        project.name != 'methanol-samples' &&
+        project.name != 'progress'
   }
   // project has tests that contribute to coverage ?
   contributesToTests = { project ->
     isJavaProject(project) &&
-        !(project.name in ['methanol-benchmarks', 'methanol-testutils', 'methanol-samples'])
+        !(project.name in
+            ['methanol-benchmarks', 'methanol-testutils', 'methanol-samples', 'progress'])
   }
   // project is included in coverage report ?
   contributesToCoverageReport = { project ->
diff --git a/methanol-samples/build.gradle b/methanol-samples/build.gradle
index 5807f53f..d6781170 100644
--- a/methanol-samples/build.gradle
+++ b/methanol-samples/build.gradle
@@ -1,18 +1,5 @@
-plugins {
-  id 'java'
-  id 'org.openjfx.javafxplugin' version '0.0.8'
-}
-
-javafx {
-  version = "14"
-  modules 'javafx.controls'
-}
-
-dependencies {
-  implementation project(':methanol')
-}
-
-task runDownloadProgressSample(type: org.javamodularity.moduleplugin.tasks.ModularJavaExec) {
-  classpath = sourceSets.main.runtimeClasspath
-  main = "$moduleName/com.github.mizosoft.methanol.samples.DownloadProgress"
+subprojects {
+  dependencies {
+    implementation project(':methanol')
+  }
 }
diff --git a/methanol-samples/progress/build.gradle b/methanol-samples/progress/build.gradle
new file mode 100644
index 00000000..334b9648
--- /dev/null
+++ b/methanol-samples/progress/build.gradle
@@ -0,0 +1,18 @@
+plugins {
+  id 'org.openjfx.javafxplugin' version '0.0.8'
+}
+
+javafx {
+  version = "14"
+  modules 'javafx.controls'
+}
+
+task runDownloadProgress(type: org.javamodularity.moduleplugin.tasks.ModularJavaExec) {
+  classpath = sourceSets.main.runtimeClasspath
+  main = "$moduleName/com.github.mizosoft.methanol.samples.DownloadProgress"
+}
+
+task runMultipartUploadProgress(type: org.javamodularity.moduleplugin.tasks.ModularJavaExec) {
+  classpath = sourceSets.main.runtimeClasspath
+  main = "$moduleName/com.github.mizosoft.methanol.samples.MultipartUploadProgress"
+}
diff --git a/methanol-samples/src/main/java/com/github/mizosoft/methanol/samples/DownloadProgress.java b/methanol-samples/progress/src/main/java/com/github/mizosoft/methanol/samples/DownloadProgress.java
similarity index 99%
rename from methanol-samples/src/main/java/com/github/mizosoft/methanol/samples/DownloadProgress.java
rename to methanol-samples/progress/src/main/java/com/github/mizosoft/methanol/samples/DownloadProgress.java
index 42745f9b..767e3e33 100644
--- a/methanol-samples/src/main/java/com/github/mizosoft/methanol/samples/DownloadProgress.java
+++ b/methanol-samples/progress/src/main/java/com/github/mizosoft/methanol/samples/DownloadProgress.java
@@ -72,10 +72,10 @@ public void start(Stage primaryStage) {
     gridPane.setVgap(10.d);
     gridPane.setPadding(new Insets(18.d));
 
-    var notGrowable = new ColumnConstraints();
-    notGrowable.setHgrow(Priority.NEVER);
     var growable = new ColumnConstraints();
     growable.setHgrow(Priority.ALWAYS);
+    var notGrowable = new ColumnConstraints();
+    notGrowable.setHgrow(Priority.NEVER);
     gridPane.getColumnConstraints().addAll(growable, notGrowable);
 
     gridPane.add(urlTextField, 0, 0);
@@ -127,6 +127,6 @@ private static BodySubscriber<OptionalLong> ofContentLength(ResponseInfo info) {
   }
 
   public static void main(String[] args) {
-    Application.launch(args);
+    launch(args);
   }
 }
diff --git a/methanol-samples/progress/src/main/java/com/github/mizosoft/methanol/samples/MultipartUploadProgress.java b/methanol-samples/progress/src/main/java/com/github/mizosoft/methanol/samples/MultipartUploadProgress.java
new file mode 100644
index 00000000..e22f0b7c
--- /dev/null
+++ b/methanol-samples/progress/src/main/java/com/github/mizosoft/methanol/samples/MultipartUploadProgress.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2019, 2020 Moataz Abdelnasser
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.github.mizosoft.methanol.samples;
+
+import com.github.mizosoft.methanol.Methanol;
+import com.github.mizosoft.methanol.MoreBodyHandlers;
+import com.github.mizosoft.methanol.MultipartBodyPublisher;
+import com.github.mizosoft.methanol.MutableRequest;
+import com.github.mizosoft.methanol.ProgressTracker;
+import com.github.mizosoft.methanol.ProgressTracker.MultipartProgress;
+import java.io.FileNotFoundException;
+import java.io.UncheckedIOException;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodySubscribers;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.ProgressBar;
+import javafx.scene.layout.ColumnConstraints;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.stage.FileChooser;
+import javafx.stage.Stage;
+
+public class MultipartUploadProgress extends Application {
+  private static final int WIDTH = 420;
+  private static final int HEIGHT = 120;
+
+  private static final String URL = "https://httpbin.org/post";
+
+  private final Methanol client = Methanol.create();
+  private final ProgressTracker tracker =
+      ProgressTracker.newBuilder()
+          .bytesTransferredThreshold(10 * 1024) // get an event every 10KB at least
+          .executor(Platform::runLater) // execute listener on JavaFX Application Thread
+          .build();
+
+  private final FileChooser fileChooser = new FileChooser();
+  private final List<Path> addedFiles = new ArrayList<>();
+
+  private final ProgressBar mainProgressBar = new ProgressBar(0.d);
+  private final ProgressBar perFileProgressBar = new ProgressBar(0.d);
+  private final Label fileNameLabel = new Label("N/A");
+  private final Button addFileButton = new Button("Add File");
+  private final Button resetButton = new Button("Reset");
+  private final Button uploadButton = new Button("Upload");
+  private final List<Button> allButtons = List.of(addFileButton, resetButton, uploadButton);
+
+  @Override
+  public void start(Stage primaryStage) {
+    var progressBarsGridPane = new GridPane();
+    progressBarsGridPane.setHgap(10.d);
+    progressBarsGridPane.setVgap(10.d);
+
+    var notGrowable = new ColumnConstraints();
+    notGrowable.setHgrow(Priority.NEVER);
+    var growable = new ColumnConstraints();
+    growable.setHgrow(Priority.ALWAYS);
+    progressBarsGridPane.getColumnConstraints().addAll(notGrowable, growable);
+
+    progressBarsGridPane.add(mainProgressBar, 0, 0, 2, 1);
+    progressBarsGridPane.add(fileNameLabel, 0, 1);
+    progressBarsGridPane.add(perFileProgressBar, 1, 1);
+    fileNameLabel.setMaxWidth(100);
+    mainProgressBar.setMaxWidth(Double.MAX_VALUE);
+    perFileProgressBar.setMaxWidth(Double.MAX_VALUE);
+
+    var buttonBox = new HBox(10.d);
+    buttonBox.setPadding(new Insets(0.d, 18.d, 0.d, 18.d));
+    buttonBox.setAlignment(Pos.CENTER);
+    for (var button : allButtons) {
+      HBox.setHgrow(button, Priority.ALWAYS);
+      button.setMaxWidth(Double.MAX_VALUE);
+      buttonBox.getChildren().add(button);
+    }
+
+    var gridPane = new GridPane();
+    gridPane.setVgap(10.d);
+    gridPane.setPadding(new Insets(18.d));
+    gridPane.add(progressBarsGridPane, 0, 0);
+    gridPane.add(buttonBox, 0, 1);
+    gridPane.getColumnConstraints().add(growable);
+
+    fileChooser.setTitle("Add File");
+
+    setAddFileListener(primaryStage);
+    setResetListener();
+    setUploadListener();
+
+    primaryStage.setTitle("Multipart Upload Progress");
+    primaryStage.setScene(new Scene(gridPane, WIDTH, HEIGHT));
+    primaryStage.show();
+  }
+
+  private void setAddFileListener(Stage primaryStage) {
+    addFileButton.setOnAction(e -> {
+      var file = fileChooser.showOpenDialog(primaryStage);
+      if (file != null) {
+        addedFiles.add(file.toPath());
+      }
+    });
+  }
+
+  private void setResetListener() {
+    resetButton.setOnAction(e -> addedFiles.clear());
+  }
+
+  private void setUploadListener() {
+    uploadButton.setOnAction(e -> {
+      mainProgressBar.setProgress(0.d);
+      perFileProgressBar.setProgress(0.d);
+      allButtons.forEach(b -> b.setDisable(true));
+      uploadFilesAsync()
+          .whenComplete(
+              (r, t) -> Platform.runLater(() -> {
+                perFileProgressBar.setProgress(0.d);
+                mainProgressBar.setProgress(0.d);
+                allButtons.forEach(b -> b.setDisable(false));
+                fileNameLabel.setText("N/A");
+              }));
+    });
+  }
+
+  private CompletableFuture<Void> uploadFilesAsync() {
+    var snapshot =
+        addedFiles.stream().filter(Files::exists).collect(Collectors.toUnmodifiableList());
+    if (snapshot.isEmpty()) {
+      return CompletableFuture.completedFuture(null);
+    }
+
+    var builder = MultipartBodyPublisher.newBuilder();
+    try {
+      for (int i = 0; i < snapshot.size(); i++) {
+        builder.filePart("file_" + i, snapshot.get(i));
+      }
+    } catch (FileNotFoundException e) {
+      throw new UncheckedIOException(e);
+    }
+
+    var request = MutableRequest.POST(
+        URL, tracker.trackingMultipart(builder.build(), this::onUploadProgress));
+    return client.sendAsync(request, MoreBodyHandlers.fromAsyncSubscriber(
+            BodySubscribers.discarding(), __ -> CompletableFuture.<Void>completedFuture(null))) // ignore body completion
+        .thenApply(HttpResponse::body);
+  }
+
+  private void onUploadProgress(MultipartProgress progress) {
+    if (progress.partChanged()) {
+      // Currently file name has to be parsed from headers
+      // Maybe a ContentDisposition class can be added in future to make this easier
+      var filename = progress.part()
+          .headers()
+          .firstValue("Content-Disposition")
+          .flatMap(MultipartUploadProgress::getFilenameFromDisposition)
+          .orElse("UNKNOWN");
+      fileNameLabel.setText(filename);
+    }
+
+    mainProgressBar.setProgress(progress.value());
+    perFileProgressBar.setProgress(progress.partProgress().value());
+  }
+
+  private static Optional<String> getFilenameFromDisposition(String disposition) {
+    int i = disposition.indexOf("filename=");
+    if (i == -1) {
+      return Optional.empty();
+    }
+
+    int j = disposition.indexOf(';', i);
+    int n = i + 9;
+    var filename = j == -1 ? disposition.substring(n) : disposition.substring(n, j);
+    if (filename.length() > 2 && filename.startsWith("\"") && filename.endsWith("\"")) {
+      filename = filename.substring(1, filename.length() - 1);
+    }
+    return Optional.of(filename);
+  }
+
+  public static void main(String[] args) {
+    launch(args);
+  }
+}
diff --git a/methanol-samples/src/main/java/module-info.java b/methanol-samples/progress/src/main/java/module-info.java
similarity index 56%
rename from methanol-samples/src/main/java/module-info.java
rename to methanol-samples/progress/src/main/java/module-info.java
index 209294d9..82c09c4e 100644
--- a/methanol-samples/src/main/java/module-info.java
+++ b/methanol-samples/progress/src/main/java/module-info.java
@@ -1,4 +1,4 @@
-open module methanol.samples {
+open module methanol.samples.progress {
   requires methanol;
   requires javafx.controls;
 }
diff --git a/methanol/src/main/java/com/github/mizosoft/methanol/Methanol.java b/methanol/src/main/java/com/github/mizosoft/methanol/Methanol.java
index afe59adb..71ef002e 100644
--- a/methanol/src/main/java/com/github/mizosoft/methanol/Methanol.java
+++ b/methanol/src/main/java/com/github/mizosoft/methanol/Methanol.java
@@ -79,7 +79,7 @@
 @SuppressWarnings("OptionalUsedAsFieldOrParameterType")
 public final class Methanol extends HttpClient {
 
-  private final HttpClient delegate;
+  private final HttpClient baseClient;
   private final Optional<String> userAgent;
   private final Optional<URI> baseUri;
   private final Optional<Duration> requestTimeout;
@@ -91,7 +91,7 @@ public final class Methanol extends HttpClient {
   private final List<Interceptor> postDecorationInterceptors;
 
   private Methanol(BaseBuilder<?> builder) {
-    delegate = builder.buildDelegateClient();
+    baseClient = builder.buildBaseClient();
     userAgent = Optional.ofNullable(builder.userAgent);
     baseUri = Optional.ofNullable(builder.baseUri);
     requestTimeout = Optional.ofNullable(builder.requestTimeout);
@@ -141,7 +141,7 @@ public <T> Publisher<HttpResponse<T>> exchange(
 
   /** Returns the underlying {@code HttpClient} used for sending requests. */
   public HttpClient underlyingClient() {
-    return delegate;
+    return baseClient;
   }
 
   /** Returns this client's {@code User-Agent}. */
@@ -189,47 +189,47 @@ public boolean autoAcceptEncoding() {
 
   @Override
   public Optional<CookieHandler> cookieHandler() {
-    return delegate.cookieHandler();
+    return baseClient.cookieHandler();
   }
 
   @Override
   public Optional<Duration> connectTimeout() {
-    return delegate.connectTimeout();
+    return baseClient.connectTimeout();
   }
 
   @Override
   public Redirect followRedirects() {
-    return delegate.followRedirects();
+    return baseClient.followRedirects();
   }
 
   @Override
   public Optional<ProxySelector> proxy() {
-    return delegate.proxy();
+    return baseClient.proxy();
   }
 
   @Override
   public SSLContext sslContext() {
-    return delegate.sslContext();
+    return baseClient.sslContext();
   }
 
   @Override
   public SSLParameters sslParameters() {
-    return delegate.sslParameters();
+    return baseClient.sslParameters();
   }
 
   @Override
   public Optional<Authenticator> authenticator() {
-    return delegate.authenticator();
+    return baseClient.authenticator();
   }
 
   @Override
   public Version version() {
-    return delegate.version();
+    return baseClient.version();
   }
 
   @Override
   public Optional<Executor> executor() {
-    return delegate.executor();
+    return baseClient.executor();
   }
 
   @Override
@@ -238,7 +238,7 @@ public <T> HttpResponse<T> send(HttpRequest request, BodyHandler<T> bodyHandler)
     requireNonNull(request, "request");
     requireNonNull(bodyHandler, "bodyHandler");
     return InterceptorChain.sendWithInterceptors(
-        delegate, request, bodyHandler, buildInterceptorQueue());
+        baseClient, request, bodyHandler, buildInterceptorQueue());
   }
 
   @Override
@@ -247,7 +247,7 @@ public <T> CompletableFuture<HttpResponse<T>> sendAsync(
     requireNonNull(request, "request");
     requireNonNull(bodyHandler, "bodyHandler");
     return InterceptorChain.sendAsyncWithInterceptors(
-        delegate, request, bodyHandler, null, buildInterceptorQueue());
+        baseClient, request, bodyHandler, null, buildInterceptorQueue());
   }
 
   @Override
@@ -258,7 +258,7 @@ public <T> CompletableFuture<HttpResponse<T>> sendAsync(
     requireNonNull(request, "request");
     requireNonNull(bodyHandler, "bodyHandler");
     return InterceptorChain.sendAsyncWithInterceptors(
-        delegate, request, bodyHandler, pushPromiseHandler, buildInterceptorQueue());
+        baseClient, request, bodyHandler, pushPromiseHandler, buildInterceptorQueue());
   }
 
   private List<Interceptor> buildInterceptorQueue() {
@@ -442,7 +442,7 @@ public B requestTimeout(Duration requestTimeout) {
 
     /**
      * Sets a default {@link MoreBodySubscribers#withReadTimeout(BodySubscriber, Duration)
-     * readtimeout}. Timeout events are scheduled using a system-wide {@code
+     * read timeout}. Timeout events are scheduled using a system-wide {@code
      * ScheduledExecutorService}.
      */
     public B readTimeout(Duration readTimeout) {
@@ -504,7 +504,7 @@ public Methanol build() {
 
     abstract B self();
 
-    abstract HttpClient buildDelegateClient();
+    abstract HttpClient buildBaseClient();
   }
 
   /** A builder for {@code Methanol} instances with a predefined {@code HttpClient}. */
@@ -522,7 +522,7 @@ WithClientBuilder self() {
     }
 
     @Override
-    HttpClient buildDelegateClient() {
+    HttpClient buildBaseClient() {
       return delegate;
     }
   }
@@ -605,7 +605,7 @@ Builder self() {
     }
 
     @Override
-    HttpClient buildDelegateClient() {
+    HttpClient buildBaseClient() {
       return delegateBuilder.build();
     }
   }
diff --git a/methanol/src/main/java/com/github/mizosoft/methanol/MultipartBodyPublisher.java b/methanol/src/main/java/com/github/mizosoft/methanol/MultipartBodyPublisher.java
index 14407b4a..a7f62f8d 100644
--- a/methanol/src/main/java/com/github/mizosoft/methanol/MultipartBodyPublisher.java
+++ b/methanol/src/main/java/com/github/mizosoft/methanol/MultipartBodyPublisher.java
@@ -428,6 +428,20 @@ private static MediaType probeMediaType(Path file) {
     }
   }
 
+  /** Used by {@code ProgressTracker} to peek part info from a {@code MultipartSubscription}. */
+  interface PartPeeker {
+
+    int peekIndex();
+
+    Part at(int index);
+
+    static PartPeeker peeking(Subscription subscription) {
+      requireArgument(
+          subscription instanceof MultipartSubscription, "not a multipart subscription");
+      return ((MultipartSubscription) subscription).partPeeker();
+    }
+  }
+
   /** Strategy for appending the boundary across parts. */
   private enum BoundaryAppender {
     FIRST("--", "\r\n"),
@@ -466,7 +480,7 @@ private static final class MultipartSubscription extends AbstractSubscription<By
     }
 
     // A tombstone to protect against race conditions that would otherwise occur if a
-    // thread tries to abort() while another tries to peekNextPart(), which might lead
+    // thread tries to abort() while another tries to readNextPartHeaders(), which might lead
     // to a newly subscribed part being missed by abort().
     private static final Subscriber<ByteBuffer> CANCELLED =
         new Subscriber<>() {
@@ -489,6 +503,23 @@ private static final class MultipartSubscription extends AbstractSubscription<By
       parts = upstream.parts();
     }
 
+    // The peeker is called serially (within downstream's onNext)
+    // by ProgressTracker so no need for synchronization.
+    PartPeeker partPeeker() {
+      return new PartPeeker() {
+        @Override
+        public int peekIndex() {
+          // subtract 1 as partIndex actually indicates the next part to subscribe, not the current
+          return Math.max(0, partIndex - 1);
+        }
+
+        @Override
+        public Part at(int index) {
+          return parts.get(index);
+        }
+      };
+    }
+
     @Override
     protected long emit(Subscriber<? super ByteBuffer> downstream, long emit) {
       long submitted = 0L;
@@ -526,10 +557,10 @@ protected void abort(boolean flowInterrupted) {
           return next;
         }
       }
-      return subscriber != CANCELLED ? peekNextPart() : null;
+      return subscriber != CANCELLED ? nextPartHeaders() : null;
     }
 
-    private @Nullable ByteBuffer peekNextPart() {
+    private @Nullable ByteBuffer nextPartHeaders() {
       StringBuilder heading = new StringBuilder();
       BoundaryAppender.get(partIndex, parts.size()).append(heading, boundary);
       if (partIndex < parts.size()) {
diff --git a/methanol/src/main/java/com/github/mizosoft/methanol/ProgressTracker.java b/methanol/src/main/java/com/github/mizosoft/methanol/ProgressTracker.java
index 2a4f6648..563ef9a6 100644
--- a/methanol/src/main/java/com/github/mizosoft/methanol/ProgressTracker.java
+++ b/methanol/src/main/java/com/github/mizosoft/methanol/ProgressTracker.java
@@ -26,8 +26,12 @@
 import static com.github.mizosoft.methanol.internal.Validate.requireArgument;
 import static java.util.Objects.requireNonNull;
 
+import com.github.mizosoft.methanol.MultipartBodyPublisher.Part;
+import com.github.mizosoft.methanol.MultipartBodyPublisher.PartPeeker;
+import com.github.mizosoft.methanol.internal.Validate;
 import com.github.mizosoft.methanol.internal.flow.AbstractSubscription;
 import com.github.mizosoft.methanol.internal.flow.FlowSupport;
+import com.github.mizosoft.methanol.internal.flow.ForwardingBodyPublisher;
 import com.github.mizosoft.methanol.internal.flow.ForwardingSubscriber;
 import java.net.http.HttpHeaders;
 import java.net.http.HttpRequest.BodyPublisher;
@@ -48,25 +52,16 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 /** Allows attaching a listener to un upload or download operation for tracking progress. */
-@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
 public final class ProgressTracker {
 
   private static final long UNKNOWN_CONTENT_LENGTH = -1;
 
-  private final long bytesTransferredThreshold;
-  private final Optional<Duration> timePassedThreshold;
-  private final boolean enclosedProgress;
-  private final Executor executor;
+  private final Options options;
   private final boolean userExecutor;
 
-  // helps with testing
-  private final Clock clock;
-
   private ProgressTracker(Builder builder) {
-    this.bytesTransferredThreshold = builder.bytesTransferredThreshold;
-    this.timePassedThreshold = Optional.ofNullable(builder.timePassedThreshold);
-    this.enclosedProgress = builder.enclosedProgress;
     var configuredExecutor = builder.executor;
+    Executor executor;
     if (configuredExecutor != null) {
       executor = configuredExecutor;
       userExecutor = true;
@@ -75,17 +70,23 @@ private ProgressTracker(Builder builder) {
       userExecutor = false;
     }
 
-    clock = builder.clock;
+    options =
+        new Options(
+            builder.bytesTransferredThreshold,
+            builder.timePassedThreshold,
+            executor,
+            builder.enclosedProgress,
+            builder.clock);
   }
 
   /** Returns the minimum number of bytes to be transferred for a progress event to be signalled. */
   public long bytesTransferredThreshold() {
-    return bytesTransferredThreshold;
+    return options.bytesTransferredThreshold;
   }
 
   /** Returns the minimum time to pass for a progress event to be signalled. */
   public Optional<Duration> timePassedThreshold() {
-    return timePassedThreshold;
+    return Optional.ofNullable(options.timePassedThreshold);
   }
 
   /**
@@ -93,12 +94,12 @@ public Optional<Duration> timePassedThreshold() {
    * progress events.
    */
   public boolean enclosedProgress() {
-    return enclosedProgress;
+    return options.enclosedProgress;
   }
 
   /** Returns the optional executor on which {@link Listener} methods are called. */
   public Optional<Executor> executor() {
-    return userExecutor ? Optional.of(executor) : Optional.empty();
+    return userExecutor ? Optional.of(options.executor) : Optional.empty();
   }
 
   /**
@@ -107,14 +108,22 @@ public Optional<Executor> executor() {
   public BodyPublisher tracking(BodyPublisher upstream, Listener listener) {
     requireNonNull(upstream, "upstream");
     requireNonNull(listener, "listener");
-    return new TrackingBodyPublisher(
-        upstream,
-        listener,
-        bytesTransferredThreshold,
-        timePassedThreshold.orElse(null),
-        enclosedProgress,
-        executor,
-        clock);
+    if (upstream instanceof MultipartBodyPublisher) {
+      return new MultipartTrackingBodyPublisher(
+          options, new MultipartListenerAdapter(listener), (MultipartBodyPublisher) upstream);
+    }
+    return new UnipartTrackingBodyPublisher(options, listener, upstream);
+  }
+
+  /**
+   * Returns a {@code BodyPublisher} that tracks the given {@code MultipartBodyPublisher}'s upload
+   * progress with per-part progress events.
+   */
+  public BodyPublisher trackingMultipart(
+      MultipartBodyPublisher upstream, MultipartListener listener) {
+    requireNonNull(upstream, "upstream");
+    requireNonNull(listener, "listener");
+    return new MultipartTrackingBodyPublisher(options, listener, upstream);
   }
 
   /**
@@ -126,15 +135,7 @@ public <T> BodySubscriber<T> tracking(
       BodySubscriber<T> downstream, Listener listener, long contentLengthIfKnown) {
     requireNonNull(downstream, "downstream");
     requireNonNull(listener, "listener");
-    return new TrackingBodySubscriber<>(
-        downstream,
-        listener,
-        contentLengthIfKnown,
-        bytesTransferredThreshold,
-        timePassedThreshold.orElse(null),
-        enclosedProgress,
-        executor,
-        clock);
+    return new TrackingBodySubscriber<>(options, listener, contentLengthIfKnown, downstream);
   }
 
   /**
@@ -151,7 +152,7 @@ private static long contentLengthIfKnown(HttpHeaders headers) {
     return headers.firstValueAsLong("Content-Length").orElse(UNKNOWN_CONTENT_LENGTH);
   }
 
-  /** Returns a default {@code ProgressTracker} with no thresholds. */
+  /** Returns a default {@code ProgressTracker} with no thresholds or executor. */
   public static ProgressTracker create() {
     return ProgressTracker.newBuilder().build();
   }
@@ -161,17 +162,8 @@ public static Builder newBuilder() {
     return new Builder();
   }
 
-  /**
-   * A listener of {@link Progress progress events}. {@code Listener} extends from {@code
-   * Subscriber<Progress>} and provides sufficient default implementations for all methods but
-   * {@code onNext}, allowing it to be used as a functional interface in most cases. Override
-   * default methods if you want to handle other subscriber notifications. Note that if progress
-   * is {@link #enclosedProgress() enclosed}, {@code onSubscribe} and {@code onComplete} can still
-   * be detected by {@code onNext} as {@code 0%} or {@link Progress#done() 100%} progress
-   * events respectively.
-   */
   @FunctionalInterface
-  public interface Listener extends Subscriber<Progress> {
+  private interface BaseListener<P extends Progress> extends Subscriber<P> {
 
     @Override
     default void onSubscribe(Subscription subscription) {
@@ -185,6 +177,22 @@ default void onError(Throwable throwable) {}
     default void onComplete() {}
   }
 
+  /**
+   * A listener of {@link Progress progress events}. {@code Listener} extends from {@code
+   * Subscriber<Progress>} and provides sufficient default implementations for all methods but
+   * {@code onNext}, allowing it to be used as a functional interface in most cases. Override
+   * default methods if you want to handle other subscriber notifications. Note that if progress is
+   * {@link #enclosedProgress() enclosed}, {@code onSubscribe} and {@code onComplete} can still be
+   * detected by {@code onNext} as {@code 0%} or {@link Progress#done() 100%} progress events
+   * respectively.
+   */
+  @FunctionalInterface
+  public interface Listener extends BaseListener<Progress> {}
+
+  /** A {@link Listener} of {@link MultipartProgress multipart progress events}. */
+  @FunctionalInterface
+  public interface MultipartListener extends BaseListener<MultipartProgress> {}
+
   /** A progress event. */
   public interface Progress {
 
@@ -228,6 +236,19 @@ default boolean determinate() {
     String toString();
   }
 
+  /** A progress event for a multipart body with per-part progress info. */
+  public interface MultipartProgress extends Progress {
+
+    /** Returns {@code true} if the currently progressing part has changed. */
+    boolean partChanged();
+
+    /** Returns the currently progressing part. */
+    Part part();
+
+    /** Returns current part's progress. */
+    Progress partProgress();
+  }
+
   /** A builder of {@code ProgressTrackers}. */
   public static final class Builder {
 
@@ -294,7 +315,212 @@ public ProgressTracker build() {
     }
   }
 
-  static final class ImmutableProgress implements Progress {
+  private static final class Options {
+
+    final long bytesTransferredThreshold;
+    final @Nullable Duration timePassedThreshold;
+    final Executor executor;
+    final boolean enclosedProgress;
+    final Clock clock;
+
+    Options(
+        long bytesTransferredThreshold,
+        @Nullable Duration timePassedThreshold,
+        Executor executor,
+        boolean enclosedProgress,
+        Clock clock) {
+      this.bytesTransferredThreshold = bytesTransferredThreshold;
+      this.timePassedThreshold = timePassedThreshold;
+      this.executor = executor;
+      this.enclosedProgress = enclosedProgress;
+      this.clock = clock;
+    }
+  }
+
+  private static final class MultipartListenerAdapter
+      extends ForwardingSubscriber<MultipartProgress> implements MultipartListener {
+
+    private final Listener listener;
+
+    MultipartListenerAdapter(Listener listener) {
+      this.listener = listener;
+    }
+
+    @Override
+    protected Subscriber<? super MultipartProgress> downstream() {
+      return listener;
+    }
+  }
+
+  private abstract static class Progression<P extends Progress> {
+
+    final long bytesTransferredThreshold;
+    final long contentLength;
+    final @Nullable Duration timePassedThreshold;
+    final Instant startTime;
+    long bytesTransferred;
+    long totalBytesTransferred;
+    Instant lastUpdateTime;
+    Instant updateTime;
+
+    Progression(
+        Instant startTime,
+        long bytesTransferredThreshold,
+        @Nullable Duration timePassedThreshold,
+        long contentLength) {
+      this.bytesTransferredThreshold = bytesTransferredThreshold;
+      this.startTime = startTime;
+      this.timePassedThreshold = timePassedThreshold;
+      this.contentLength = contentLength;
+      lastUpdateTime = startTime;
+      updateTime = startTime;
+    }
+
+    void updateProgress(Instant updateTime, long byteCount) {
+      this.updateTime = updateTime;
+      bytesTransferred += byteCount;
+      totalBytesTransferred += byteCount;
+    }
+
+    boolean shouldSignalProgress() {
+      return bytesTransferred >= bytesTransferredThreshold
+          && (timePassedThreshold == null
+              || updateTime.compareTo(lastUpdateTime.plus(timePassedThreshold)) >= 0);
+    }
+
+    void rewind() {
+      bytesTransferred = 0L;
+      lastUpdateTime = updateTime;
+    }
+
+    abstract P snapshot(boolean lastlyEnclosing);
+
+    abstract P zeroProgress();
+  }
+
+  private static final class UnipartProgression extends Progression<Progress> {
+
+    UnipartProgression(
+        Instant startTime,
+        long bytesTransferredThreshold,
+        @Nullable Duration timePassedThreshold,
+        long contentLength) {
+      super(startTime, bytesTransferredThreshold, timePassedThreshold, contentLength);
+    }
+
+    @Override
+    Progress snapshot(boolean lastlyEnclosing) {
+      return new ImmutableProgress(
+          bytesTransferred,
+          totalBytesTransferred,
+          contentLength,
+          Duration.between(lastUpdateTime, updateTime),
+          Duration.between(startTime, updateTime),
+          lastlyEnclosing);
+    }
+
+    @Override
+    Progress zeroProgress() {
+      return new ImmutableProgress(0L, 0L, contentLength, Duration.ZERO, Duration.ZERO, false);
+    }
+  }
+
+  private static final class MultipartProgression extends Progression<MultipartProgress> {
+
+    private final PartPeeker peeker;
+    private int currentPartIndex;
+
+    // becomes non-null on first updateProgress() call
+    private @MonotonicNonNull UnipartProgression currentPartProgression;
+
+    // The part is prefixed with headers (a ByteBuffer signal) so
+    // one signal must be ignored to begin progressing the part itself
+    private boolean partIsProgressing;
+
+    // true only right after a part is updated before a MultipartProgress snapshot
+    private boolean partChangePending;
+
+    MultipartProgression(
+        Instant startTime,
+        long bytesTransferredThreshold,
+        @Nullable Duration timePassedThreshold,
+        long contentLength,
+        PartPeeker peeker) {
+      super(startTime, bytesTransferredThreshold, timePassedThreshold, contentLength);
+      this.peeker = peeker;
+    }
+
+    @Override
+    void updateProgress(Instant updateTime, long byteCount) {
+      super.updateProgress(updateTime, byteCount);
+
+      long partByteCount;
+      if (partIsProgressing) {
+        partByteCount = byteCount;
+      } else {
+        partIsProgressing = true;
+        partByteCount = 0L;
+      }
+
+      var progression = Validate.castNonNull(currentPartProgression);
+      progression.updateProgress(updateTime, partByteCount);
+    }
+
+    @Override
+    void rewind() {
+      super.rewind();
+
+      var progression = Validate.castNonNull(currentPartProgression);
+      progression.rewind();
+    }
+
+    @Override
+    MultipartProgress snapshot(boolean lastlyEnclosing) {
+      return new ImmutableMultipartProgress(
+          bytesTransferred,
+          totalBytesTransferred,
+          contentLength,
+          Duration.between(lastUpdateTime, updateTime),
+          Duration.between(startTime, updateTime),
+          lastlyEnclosing,
+          partChanged(),
+          peeker.at(currentPartIndex),
+          Validate.castNonNull(currentPartProgression).snapshot(lastlyEnclosing));
+    }
+
+    @Override
+    MultipartProgress zeroProgress() {
+      var firstPart = peeker.at(0); // at least one part is guaranteed to exist
+      return new ImmutableMultipartProgress(
+          0L, 0L, contentLength, Duration.ZERO, Duration.ZERO, false, true, firstPart,
+          new ImmutableProgress(0L, 0L, firstPart.bodyPublisher().contentLength(),
+              Duration.ZERO, Duration.ZERO, false));
+    }
+
+    void updatePartIfNeeded(Instant newPartStartTime) {
+      if (currentPartProgression == null || currentPartIndex != peeker.peekIndex()) {
+        currentPartIndex = peeker.peekIndex();
+        currentPartProgression = newPartProgression(newPartStartTime, peeker.at(currentPartIndex));
+        partChangePending = true;
+        partIsProgressing = false;
+      }
+    }
+
+    private boolean partChanged() {
+      if (partChangePending) {
+        partChangePending = false;
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+    private UnipartProgression newPartProgression(Instant startTime, Part part) {
+      return new UnipartProgression(startTime, 0, null, part.bodyPublisher().contentLength());
+    }
+  }
+
+  static class ImmutableProgress implements Progress {
 
     private final long bytesTransferred;
     private final long totalBytesTransferred;
@@ -361,49 +587,84 @@ public String toString() {
     }
   }
 
-  private abstract static class AbstractTrackingSubscriber<B> extends ForwardingSubscriber<B> {
+  static final class ImmutableMultipartProgress extends ImmutableProgress
+      implements MultipartProgress {
+
+    private final boolean partChanged;
+    private final Part part;
+    private final Progress partProgress;
+
+    ImmutableMultipartProgress(
+        long bytesTransferred,
+        long totalBytesTransferred,
+        long contentLength,
+        Duration timePassed,
+        Duration totalTimePassed,
+        boolean lastlyEnclosing,
+        boolean partChanged,
+        Part part,
+        Progress partProgress) {
+      super(
+          bytesTransferred,
+          totalBytesTransferred,
+          contentLength,
+          timePassed,
+          totalTimePassed,
+          lastlyEnclosing);
+      this.partChanged = partChanged;
+      this.part = part;
+      this.partProgress = partProgress;
+    }
+
+    @Override
+    public boolean partChanged() {
+      return partChanged;
+    }
+
+    @Override
+    public Part part() {
+      return part;
+    }
+
+    @Override
+    public Progress partProgress() {
+      return partProgress;
+    }
+  }
+
+  private abstract static class AbstractTrackingSubscriber<
+          B, P extends Progress, R extends Progression<P>>
+      extends ForwardingSubscriber<B> {
+
+    final Options options;
+    final BaseListener<P> listener;
+    final long contentLength;
 
-    private final Listener listener;
-    private final long contentLength;
-    private final long bytesTransferredThreshold;
-    private final @Nullable Duration timePassedThreshold;
-    private final boolean enclosedProgress;
-    private final Executor executor;
     private @Nullable ProgressSubscription progressSubscription;
     private boolean signalledCompletedProgress;
-    private final Clock clock;
 
-    AbstractTrackingSubscriber(
-        Listener listener,
-        long contentLength,
-        long bytesTransferredThreshold,
-        @Nullable Duration timePassedThreshold,
-        boolean enclosedProgress,
-        Executor executor,
-        Clock clock) {
+    AbstractTrackingSubscriber(Options options, BaseListener<P> listener, long contentLength) {
+      this.options = options;
       this.listener = listener;
       this.contentLength = contentLength;
-      this.bytesTransferredThreshold = bytesTransferredThreshold;
-      this.timePassedThreshold = timePassedThreshold;
-      this.enclosedProgress = enclosedProgress;
-      this.executor = executor;
-      this.clock = clock;
     }
 
     abstract long countBytes(B batch);
 
+    abstract R createProgression(Instant startTime, Subscription upstreamSubscription);
+
     @Override
     public void onSubscribe(Subscription subscription) {
       if (upstream.setOrCancel(subscription)) {
         downstream().onSubscribe(subscription);
-        listenerOnSubscribe();
+        listenerOnSubscribe(createProgression(options.clock.instant(), subscription));
       }
     }
 
     @Override
-    public void onNext(B item) {
-      listenerOnNext(countBytes(item));
-      super.onNext(item);
+    public void onNext(B batch) {
+      listenerOnNext(countBytes(batch));
+      super.onNext(batch);
     }
 
     @Override
@@ -424,13 +685,17 @@ public void onComplete() {
       }
     }
 
-    private void listenerOnSubscribe() {
-      var subscription = new ProgressSubscription(listener, executor, clock.instant());
+    @Nullable P updateProgress(R progression, Instant updateTime, long bytesTransferred) {
+      progression.updateProgress(updateTime, bytesTransferred);
+      return progression.shouldSignalProgress() ? progression.snapshot(false) : null;
+    }
+
+    private void listenerOnSubscribe(R progression) {
+      var subscription = new ProgressSubscription(progression);
       progressSubscription = subscription;
-      if (enclosedProgress) {
+      if (options.enclosedProgress) {
         // put 0% progress
-        subscription.progressEvents.offer(
-            new ImmutableProgress(0L, 0L, contentLength, Duration.ZERO, Duration.ZERO, false));
+        subscription.progressEvents.offer(progression.zeroProgress());
       }
       subscription.signal(true);
     }
@@ -438,11 +703,12 @@ private void listenerOnSubscribe() {
     private void listenerOnNext(long bytesTransferred) {
       var subscription = progressSubscription;
       if (subscription != null) {
-        subscription.updateProgress(bytesTransferred);
-        if (subscription.shouldSignalProgress()) {
-          var progress = subscription.currentProgress(false);
+        var progression = subscription.progression;
+        var progress = updateProgress(progression, options.clock.instant(), bytesTransferred);
+        if (progress != null) {
           signalledCompletedProgress = progress.done();
-          subscription.resetProgress();
+
+          progression.rewind();
           subscription.signalProgress(progress);
         }
       }
@@ -454,40 +720,36 @@ private void listenerOnComplete(@Nullable Throwable throwable) {
         if (throwable != null) {
           subscription.signalError(throwable);
         } else {
+          var progression = subscription.progression;
           // signal 100% progress if enclosing & not signalled from onNext
-          if (enclosedProgress && !signalledCompletedProgress) {
-            subscription.updateProgress(0L); // update time passed
-            subscription.progressEvents.offer(subscription.currentProgress(true));
+          if (options.enclosedProgress && !signalledCompletedProgress) {
+            progression.updateProgress(options.clock.instant(), 0L); // update time
+            subscription.progressEvents.offer(progression.snapshot(true));
           }
+
           subscription.signalCompletion();
         }
       }
     }
 
-    private final class ProgressSubscription extends AbstractSubscription<Progress> {
+    private final class ProgressSubscription extends AbstractSubscription<P> {
 
-      private final Instant startTime;
-      private long bytesTransferred;
-      private long totalBytesTransferred;
-      private Instant lastUpdateTime;
-      private Instant updateTime;
+      final R progression;
+      final ConcurrentLinkedQueue<P> progressEvents;
 
-      private final ConcurrentLinkedQueue<Progress> progressEvents;
       private volatile boolean complete;
 
-      ProgressSubscription(Listener listener, Executor executor, Instant startTime) {
-        super(listener, executor);
-        this.startTime = startTime;
-        lastUpdateTime = startTime;
-        updateTime = startTime;
-        this.progressEvents = new ConcurrentLinkedQueue<>();
+      ProgressSubscription(R progression) {
+        super(listener, options.executor);
+        this.progression = progression;
+        progressEvents = new ConcurrentLinkedQueue<>();
       }
 
       @Override
-      protected long emit(Subscriber<? super Progress> downstream, long emit) {
+      protected long emit(Subscriber<? super P> downstream, long emit) {
         long submitted = 0L;
         while (true) {
-          Progress progress;
+          P progress;
           if (progressEvents.isEmpty() && complete) {
             cancelOnComplete(downstream);
             return 0L;
@@ -508,34 +770,7 @@ protected void abort(boolean flowInterrupted) {
         AbstractTrackingSubscriber.this.progressSubscription = null;
       }
 
-      void updateProgress(long byteCount) {
-        bytesTransferred += byteCount;
-        totalBytesTransferred += byteCount;
-        updateTime = clock.instant();
-      }
-
-      boolean shouldSignalProgress() {
-        return bytesTransferred >= bytesTransferredThreshold
-            && (timePassedThreshold == null
-                || updateTime.compareTo(lastUpdateTime.plus(timePassedThreshold)) >= 0);
-      }
-
-      void resetProgress() {
-        bytesTransferred = 0L;
-        lastUpdateTime = updateTime;
-      }
-
-      Progress currentProgress(boolean lastlyEnclosing) {
-        return new ImmutableProgress(
-            bytesTransferred,
-            totalBytesTransferred,
-            contentLength,
-            Duration.between(lastUpdateTime, updateTime),
-            Duration.between(startTime, updateTime),
-            lastlyEnclosing);
-      }
-
-      void signalProgress(Progress progress) {
+      void signalProgress(P progress) {
         progressEvents.offer(progress);
         signal(false); // signal drain task
       }
@@ -547,94 +782,42 @@ void signalCompletion() {
     }
   }
 
-  private static final class TrackingBodyPublisher implements BodyPublisher {
+  /** Common superclass for request Unipart and Multipart tracking subscribers. */
+  private abstract static class AbstractRequestTrackingSubscriber<
+          P extends Progress, R extends Progression<P>>
+      extends AbstractTrackingSubscriber<ByteBuffer, P, R> {
 
-    private final BodyPublisher upstream;
-    private final Listener listener;
-    private final long bytesTransferredThreshold;
-    private final @Nullable Duration timePassedThreshold;
-    private final boolean enclosedProgress;
-    private final Executor executor;
-    private final Clock clock;
-
-    TrackingBodyPublisher(
-        BodyPublisher upstream,
-        Listener listener,
-        long bytesTransferredThreshold,
-        @Nullable Duration timePassedThreshold,
-        boolean enclosedProgress,
-        Executor executor,
-        Clock clock) {
-      this.upstream = upstream;
-      this.listener = listener;
-      this.bytesTransferredThreshold = bytesTransferredThreshold;
-      this.timePassedThreshold = timePassedThreshold;
-      this.enclosedProgress = enclosedProgress;
-      this.executor = executor;
-      this.clock = clock;
-    }
+    private final Subscriber<? super ByteBuffer> downstream;
 
-    @Override
-    public long contentLength() {
-      return upstream.contentLength();
+    AbstractRequestTrackingSubscriber(
+        Options options,
+        BaseListener<P> listener,
+        long contentLength,
+        Subscriber<? super ByteBuffer> downstream) {
+      super(options, listener, contentLength);
+      this.downstream = downstream;
     }
 
     @Override
-    public void subscribe(Subscriber<? super ByteBuffer> subscriber) {
-      requireNonNull(subscriber);
-      upstream.subscribe(new TrackingSubscriber(subscriber, this));
+    long countBytes(ByteBuffer batch) {
+      return batch.remaining();
     }
 
-    private static final class TrackingSubscriber extends AbstractTrackingSubscriber<ByteBuffer> {
-
-      private final Subscriber<? super ByteBuffer> downstream;
-
-      TrackingSubscriber(Subscriber<? super ByteBuffer> downstream, TrackingBodyPublisher parent) {
-        super(
-            parent.listener,
-            parent.contentLength(),
-            parent.bytesTransferredThreshold,
-            parent.timePassedThreshold,
-            parent.enclosedProgress,
-            parent.executor,
-            parent.clock);
-        this.downstream = downstream;
-      }
-
-      @Override
-      long countBytes(ByteBuffer batch) {
-        return batch.remaining();
-      }
-
-      @Override
-      protected Subscriber<? super ByteBuffer> downstream() {
-        return downstream;
-      }
+    @Override
+    protected Subscriber<? super ByteBuffer> downstream() {
+      return downstream;
     }
   }
 
   private static final class TrackingBodySubscriber<T>
-      extends AbstractTrackingSubscriber<List<ByteBuffer>> implements BodySubscriber<T> {
+      extends AbstractTrackingSubscriber<List<ByteBuffer>, Progress, UnipartProgression>
+      implements BodySubscriber<T> {
 
     private final BodySubscriber<T> downstream;
 
     TrackingBodySubscriber(
-        BodySubscriber<T> downstream,
-        Listener listener,
-        long contentLength,
-        long bytesTransferredThreshold,
-        @Nullable Duration timePassedThreshold,
-        boolean enclosedProgress,
-        Executor executor,
-        Clock clock) {
-      super(
-          listener,
-          contentLength,
-          bytesTransferredThreshold,
-          timePassedThreshold,
-          enclosedProgress,
-          executor,
-          clock);
+        Options options, Listener listener, long contentLength, BodySubscriber<T> downstream) {
+      super(options, listener, contentLength);
       this.downstream = downstream;
     }
 
@@ -647,6 +830,12 @@ long countBytes(List<ByteBuffer> batch) {
       return count;
     }
 
+    @Override
+    UnipartProgression createProgression(Instant startTime, Subscription ignored) {
+      return new UnipartProgression(
+          startTime, options.bytesTransferredThreshold, options.timePassedThreshold, contentLength);
+    }
+
     @Override
     protected Subscriber<? super List<ByteBuffer>> downstream() {
       return downstream;
@@ -657,4 +846,109 @@ public CompletionStage<T> getBody() {
       return downstream.getBody();
     }
   }
+
+  private abstract static class AbstractTrackingBodyPublisher<
+          P extends Progress, R extends Progression<P>>
+      extends ForwardingBodyPublisher {
+
+    final Options options;
+    final BaseListener<P> listener;
+
+    AbstractTrackingBodyPublisher(
+        Options options, BaseListener<P> listener, BodyPublisher upstream) {
+      super(upstream);
+      this.options = options;
+      this.listener = listener;
+    }
+
+    abstract AbstractRequestTrackingSubscriber<P, R> tracking(
+        Subscriber<? super ByteBuffer> downstream);
+
+    @Override
+    public void subscribe(Subscriber<? super ByteBuffer> subscriber) {
+      requireNonNull(subscriber);
+      upstream().subscribe(tracking(subscriber));
+    }
+  }
+
+  private static final class UnipartTrackingBodyPublisher
+      extends AbstractTrackingBodyPublisher<Progress, UnipartProgression> {
+
+    UnipartTrackingBodyPublisher(Options options, Listener listener, BodyPublisher upstream) {
+      super(options, listener, upstream);
+    }
+
+    @Override
+    AbstractRequestTrackingSubscriber<Progress, UnipartProgression> tracking(
+        Subscriber<? super ByteBuffer> downstream) {
+      return new UnipartTrackingSubscriber(options, listener, contentLength(), downstream);
+    }
+
+    private static final class UnipartTrackingSubscriber
+        extends AbstractRequestTrackingSubscriber<Progress, UnipartProgression> {
+
+      UnipartTrackingSubscriber(
+          Options options,
+          BaseListener<Progress> listener,
+          long contentLength,
+          Subscriber<? super ByteBuffer> downstream) {
+        super(options, listener, contentLength, downstream);
+      }
+
+      @Override
+      UnipartProgression createProgression(Instant startTime, Subscription ignored) {
+        return new UnipartProgression(
+            startTime,
+            options.bytesTransferredThreshold,
+            options.timePassedThreshold,
+            contentLength);
+      }
+    }
+  }
+
+  private static final class MultipartTrackingBodyPublisher
+      extends AbstractTrackingBodyPublisher<MultipartProgress, MultipartProgression> {
+
+    MultipartTrackingBodyPublisher(
+        Options options,
+        BaseListener<MultipartProgress> listener,
+        MultipartBodyPublisher upstream) {
+      super(options, listener, upstream);
+    }
+
+    @Override
+    AbstractRequestTrackingSubscriber<MultipartProgress, MultipartProgression> tracking(
+        Subscriber<? super ByteBuffer> downstream) {
+      return new MultipartProgressSubscriber(options, listener, contentLength(), downstream);
+    }
+
+    private static final class MultipartProgressSubscriber
+        extends AbstractRequestTrackingSubscriber<MultipartProgress, MultipartProgression> {
+
+      MultipartProgressSubscriber(
+          Options options,
+          BaseListener<MultipartProgress> listener,
+          long contentLength,
+          Subscriber<? super ByteBuffer> downstream) {
+        super(options, listener, contentLength, downstream);
+      }
+
+      @Override
+      MultipartProgression createProgression(Instant startTime, Subscription upstreamSubscription) {
+        return new MultipartProgression(
+            startTime,
+            options.bytesTransferredThreshold,
+            options.timePassedThreshold,
+            contentLength,
+            PartPeeker.peeking(upstreamSubscription));
+      }
+
+      @Override
+      @Nullable MultipartProgress updateProgress(
+          MultipartProgression progression, Instant updateTime, long bytesTransferred) {
+        progression.updatePartIfNeeded(updateTime); // updateTime is to be the start time of the next part
+        return super.updateProgress(progression, updateTime, bytesTransferred);
+      }
+    }
+  }
 }
diff --git a/methanol/src/main/java/com/github/mizosoft/methanol/internal/Utils.java b/methanol/src/main/java/com/github/mizosoft/methanol/internal/Utils.java
index 9aa19a4f..19432f88 100644
--- a/methanol/src/main/java/com/github/mizosoft/methanol/internal/Utils.java
+++ b/methanol/src/main/java/com/github/mizosoft/methanol/internal/Utils.java
@@ -96,4 +96,9 @@ public static int copyRemaining(ByteBuffer src, ByteBuffer dst) {
     src.limit(srcLimit);
     return toCopy;
   }
+
+  @SuppressWarnings({"TypeParameterUnusedInFormals", "unused"})
+  public static <T> T TODO() {
+    throw new UnsupportedOperationException("not implemented");
+  }
 }
diff --git a/methanol/src/main/java/com/github/mizosoft/methanol/internal/extensions/ForwardingMimeBodyPublisher.java b/methanol/src/main/java/com/github/mizosoft/methanol/internal/extensions/ForwardingMimeBodyPublisher.java
index eda552d4..49b48cad 100644
--- a/methanol/src/main/java/com/github/mizosoft/methanol/internal/extensions/ForwardingMimeBodyPublisher.java
+++ b/methanol/src/main/java/com/github/mizosoft/methanol/internal/extensions/ForwardingMimeBodyPublisher.java
@@ -26,33 +26,21 @@
 
 import com.github.mizosoft.methanol.MediaType;
 import com.github.mizosoft.methanol.MimeBodyPublisher;
+import com.github.mizosoft.methanol.internal.flow.ForwardingBodyPublisher;
 import java.net.http.HttpRequest.BodyPublisher;
-import java.nio.ByteBuffer;
-import java.util.concurrent.Flow.Subscriber;
 
-public final class ForwardingMimeBodyPublisher implements MimeBodyPublisher {
+public final class ForwardingMimeBodyPublisher extends ForwardingBodyPublisher
+    implements MimeBodyPublisher {
 
-  private final BodyPublisher basePublisher;
   private final MediaType mediaType;
 
-  public ForwardingMimeBodyPublisher(BodyPublisher basePublisher, MediaType mediaType) {
-    this.basePublisher = requireNonNull(basePublisher, "basePublisher");
-    this.mediaType = requireNonNull(mediaType, "mediaType");
+  public ForwardingMimeBodyPublisher(BodyPublisher upstream, MediaType mediaType) {
+    super(upstream);
+    this.mediaType = requireNonNull(mediaType);
   }
 
   @Override
   public MediaType mediaType() {
     return mediaType;
   }
-
-  @Override
-  public long contentLength() {
-    return basePublisher.contentLength();
-  }
-
-  @Override
-  public void subscribe(Subscriber<? super ByteBuffer> subscriber) {
-    requireNonNull(subscriber);
-    basePublisher.subscribe(subscriber);
-  }
 }
diff --git a/methanol/src/main/java/com/github/mizosoft/methanol/internal/flow/ForwardingBodyPublisher.java b/methanol/src/main/java/com/github/mizosoft/methanol/internal/flow/ForwardingBodyPublisher.java
new file mode 100644
index 00000000..9dfcc123
--- /dev/null
+++ b/methanol/src/main/java/com/github/mizosoft/methanol/internal/flow/ForwardingBodyPublisher.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2019, 2020 Moataz Abdelnasser
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.github.mizosoft.methanol.internal.flow;
+
+import static java.util.Objects.requireNonNull;
+
+import java.net.http.HttpRequest.BodyPublisher;
+import java.nio.ByteBuffer;
+import java.util.concurrent.Flow.Subscriber;
+
+public class ForwardingBodyPublisher implements BodyPublisher {
+
+  private final BodyPublisher upstream;
+
+  protected ForwardingBodyPublisher(BodyPublisher upstream) {
+    this.upstream = requireNonNull(upstream);
+  }
+
+  protected final BodyPublisher upstream() {
+    return upstream;
+  }
+
+  @Override
+  public long contentLength() {
+    return upstream.contentLength();
+  }
+
+  @Override
+  public void subscribe(Subscriber<? super ByteBuffer> subscriber) {
+    requireNonNull(subscriber);
+    upstream.subscribe(subscriber);
+  }
+}
diff --git a/methanol/src/test/java/com/github/mizosoft/methanol/ProgressTrackerTest.java b/methanol/src/test/java/com/github/mizosoft/methanol/ProgressTrackerTest.java
index 51b9a263..d6cdd337 100644
--- a/methanol/src/test/java/com/github/mizosoft/methanol/ProgressTrackerTest.java
+++ b/methanol/src/test/java/com/github/mizosoft/methanol/ProgressTrackerTest.java
@@ -29,6 +29,8 @@
 import com.github.mizosoft.methanol.ProgressTracker.Builder;
 import com.github.mizosoft.methanol.ProgressTracker.ImmutableProgress;
 import com.github.mizosoft.methanol.ProgressTracker.Listener;
+import com.github.mizosoft.methanol.ProgressTracker.MultipartListener;
+import com.github.mizosoft.methanol.ProgressTracker.MultipartProgress;
 import com.github.mizosoft.methanol.ProgressTracker.Progress;
 import com.github.mizosoft.methanol.internal.flow.FlowSupport;
 import com.github.mizosoft.methanol.testutils.BodyCollector;
@@ -54,6 +56,7 @@
 import java.util.concurrent.Flow;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.function.Consumer;
+import java.util.stream.IntStream;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -174,6 +177,73 @@ void trackUploadProgressWithError() {
     assertEquals(1, listener.errors);
   }
 
+  @Test
+  void trackMultipartUploadProgressNoThreshold() {
+    int batchSize = 64;
+    int[] partCounts = {4, 2, 1};
+    int count = IntStream.of(partCounts).sum();
+    var tracker = withVirtualClock().build();
+    var listener = new TestMultipartListener();
+    var builder = MultipartBodyPublisher.newBuilder();
+    for (int i = 0; i < partCounts.length; i++) {
+      builder.formPart("part_" + i, bodyPublisher(batchSize, partCounts[i]));
+    }
+    var multipartBody = builder.build();
+    var trackedUpstream = tracker.trackingMultipart(multipartBody, listener);
+
+    trackedUpstream.subscribe(new TestSubscriber<>());
+
+    listener.awaitComplete();
+    // enclosed progress receives additional 0%
+    // 100% will already be received from onNext as there is no lastly missed progress
+    // also each part will account for an additional progress event for each headers
+    // and finally 1 for the ending boundary
+    int signalCount = count + 1 + partCounts.length + 1;
+    assertEquals(signalCount, listener.nexts);
+
+    // 0% progress
+    assertProgress(
+        listener.items.remove(),
+        0L,
+        0L,
+        multipartBody.contentLength(),
+        Duration.ZERO,
+        Duration.ZERO,
+        false);
+
+    for (int partIndex = 0; partIndex < partCounts.length; partIndex++) {
+      // for each part we get: part headers batch + batches representing part's body
+      int progressCountForPart = partCounts[partIndex] + 1;
+      for (int i = 0; i < progressCountForPart; i++) {
+        var progress = listener.items.remove();
+        assertEquals(multipartBody.parts().get(partIndex), progress.part());
+        assertEquals(i == 0, progress.partChanged(), i + ", " + partIndex);
+
+        long length = progress.part().bodyPublisher().contentLength();
+        assertProgress(
+            progress.partProgress(),
+            i > 0 ? batchSize : 0, // current
+            i * batchSize, // total
+            length,
+            i > 0 ? virtualTick : Duration.ZERO, // current
+            virtualTick.multipliedBy(i), // total
+            i * batchSize == length);
+      }
+    }
+
+    // end boundary
+    assertProgress(
+        listener.items.remove(),
+        -1, // ¯\_(ツ)_/¯
+        multipartBody.contentLength(),
+        multipartBody.contentLength(),
+        virtualTick,
+        virtualTick.multipliedBy(signalCount - 1),
+        true);
+
+    assertTrue(listener.items.isEmpty());
+  }
+
   @Test
   void trackUploadProgressWithByteThreshold() {
     int batchSize = 64;
@@ -397,6 +467,21 @@ private static long countBytes(Collection<List<ByteBuffer>> items) {
     return items.stream().flatMap(Collection::stream).mapToLong(ByteBuffer::remaining).sum();
   }
 
+  private static void assertProgress(
+      Progress progress,
+      long transferred, long totalTransferred, long contentLength,
+      Duration time, Duration totalTime,
+      boolean completed) {
+    if (transferred >= 0) {
+      assertEquals(transferred, progress.bytesTransferred());
+    }
+    assertEquals(totalTransferred, progress.totalBytesTransferred());
+    assertEquals(contentLength, progress.contentLength());
+    assertEquals(time, progress.timePassed());
+    assertEquals(totalTime, progress.totalTimePassed());
+    assertEquals(completed, progress.done());
+  }
+
   private static final class TestListener
       extends TestSubscriber<Progress> implements Listener {
 
@@ -407,16 +492,19 @@ void assertNext(
         Duration time, Duration totalTime,
         boolean completed) {
       assertFalse(items.isEmpty());
-      var progress = items.poll();
-      assertEquals(transferred, progress.bytesTransferred());
-      assertEquals(totalTransferred, progress.totalBytesTransferred());
-      assertEquals(contentLength, progress.contentLength());
-      assertEquals(time, progress.timePassed());
-      assertEquals(totalTime, progress.totalTimePassed());
-      assertEquals(completed, progress.done());
+      assertProgress(
+          items.poll(),
+          transferred, totalTransferred, contentLength,
+          time, totalTime, completed);
     }
   }
 
+  private static final class TestMultipartListener
+      extends TestSubscriber<MultipartProgress> implements MultipartListener {
+
+    TestMultipartListener() {}
+  }
+
   private static final class VirtualClock extends Clock {
 
     private final Duration tick;
diff --git a/settings.gradle b/settings.gradle
index ed810b8c..6f180c89 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -11,6 +11,7 @@ include 'methanol-brotli'
 include 'methanol-blackbox'
 include 'methanol-benchmarks'
 include 'methanol-samples'
+include 'methanol-samples:progress'
 // only include native brotli-jni project if explicitly requested
 if (settings.hasProperty('includeBrotliJni')
     || settings.gradle.startParameter.taskNames.contains('installBrotli')) {