diff --git a/application/src/main/java/org/opentripplanner/graph_builder/module/osm/EscalatorProcessor.java b/application/src/main/java/org/opentripplanner/graph_builder/module/osm/EscalatorProcessor.java
index c8f4e0e0042..40695e7c67c 100644
--- a/application/src/main/java/org/opentripplanner/graph_builder/module/osm/EscalatorProcessor.java
+++ b/application/src/main/java/org/opentripplanner/graph_builder/module/osm/EscalatorProcessor.java
@@ -45,8 +45,8 @@ public void buildEscalatorEdge(OsmWay escalatorWay, double length) {
       issueStore.add(
         Issue.issue(
           "InvalidDuration",
-          "Duration for osm node %d is not a valid duration: '%s'; it's replaced with 'Optional.empty()' (unknown).",
-          escalatorWay.getId(),
+          "Duration for osm node {} is not a valid duration: '{}'; the value is ignored.",
+          escalatorWay.url(),
           v
         )
       )
@@ -59,7 +59,7 @@ public void buildEscalatorEdge(OsmWay escalatorWay, double length) {
           Issue.issue(
             "InvalidDuration",
             "Duration for osm node {} makes implied speed {} be outside acceptable range.",
-            escalatorWay.getId(),
+            escalatorWay.url(),
             speed
           )
         );
diff --git a/application/src/main/java/org/opentripplanner/osm/model/OsmWay.java b/application/src/main/java/org/opentripplanner/osm/model/OsmWay.java
index 0cc19363a0a..a620545f521 100644
--- a/application/src/main/java/org/opentripplanner/osm/model/OsmWay.java
+++ b/application/src/main/java/org/opentripplanner/osm/model/OsmWay.java
@@ -3,13 +3,11 @@
 import gnu.trove.list.TLongList;
 import gnu.trove.list.array.TLongArrayList;
 import java.time.Duration;
-import java.time.format.DateTimeParseException;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
 import org.opentripplanner.graph_builder.module.osm.StreetTraversalPermissionPair;
 import org.opentripplanner.street.model.StreetTraversalPermission;
-import org.opentripplanner.utils.time.DurationUtils;
 
 public class OsmWay extends OsmWithTags {
 
@@ -136,7 +134,7 @@ public boolean isEscalator() {
   }
 
   public Optional<Duration> getDuration(Consumer<String> errorHandler) {
-    return getTagAsDuration("duration", errorHandler);
+    return getTagValueAsDuration("duration", errorHandler);
   }
 
   public boolean isForwardEscalator() {
diff --git a/application/src/main/java/org/opentripplanner/osm/model/OsmWithTags.java b/application/src/main/java/org/opentripplanner/osm/model/OsmWithTags.java
index 74d1ffd25f5..ab50fb0ec1b 100644
--- a/application/src/main/java/org/opentripplanner/osm/model/OsmWithTags.java
+++ b/application/src/main/java/org/opentripplanner/osm/model/OsmWithTags.java
@@ -229,36 +229,43 @@ public OptionalInt getTagAsInt(String tag, Consumer<String> errorHandler) {
    *   hh:mm
    *   hh:mm:ss
    * and where the leading value is not limited to any maximum.
+   * See <a href="https://wiki.openstreetmap.org/wiki/Key:duration">OSM wiki definition
+   * of duration</a>.
+   *
    * @param duration string in format mm, hh:mm, or hh:mm:ss
    * @return Duration
    * @throws DateTimeParseException on bad input
    */
   public static Duration parseOsmDuration(String duration) {
-    // Unfortunately DateFormatParserBuilder doesn't quite do enough for this case.
-    // It has the capability for expressing optional parts, so it could express hh(:mm(:ss)?)?
-    // but it cannot express (hh:)?mm(:ss)? where the existence of (:ss) implies the existence
-    // of (hh:). Even if it did, it would not be able to handle the cases where hours are
-    // greater than 23 or (if there is no hours part at all) minutes are greater than 59, which
-    // are both allowed by the spec and exist in OSM data. Durations are not LocalTimes after
-    // all, in parsing a LocalTime it makes sense and is correct that hours cannot be more than
-    // 23 or minutes more than 59, but in durations if you have capped the largest unit, it is
-    // reasonable for the amount of the largest unit to be as large as it needs to be.
+    /*
+     * Unfortunately DateFormatParserBuilder doesn't quite do enough for this case.
+     * It has the capability for expressing optional parts, so it could express hh(:mm(:ss)?)?
+     * but it cannot express (hh:)?mm(:ss)? where the existence of (:ss) implies the existence
+     * of (hh:). Even if it did, it would not be able to handle the cases where hours are
+     * greater than 23 or (if there is no hours part at all) minutes are greater than 59, which
+     * are both allowed by the spec and exist in OSM data. Durations are not LocalTimes after
+     * all, in parsing a LocalTime it makes sense and is correct that hours cannot be more than
+     * 23 or minutes more than 59, but in durations if you have capped the largest unit, it is
+     * reasonable for the amount of the largest unit to be as large as it needs to be.
+     */
     int colonCount = (int) duration.chars().filter(ch -> ch == ':').count();
     if (colonCount <= 2) {
       try {
         int i, j;
         long hours, minutes, seconds;
-        // The first :-separated element can be any width, and has no maximum. It still has
-        // to be non-negative. The following elements must be 2 characters wide, non-negative,
-        // and less than 60.
+        /*
+         * The first :-separated element can be any width, and has no maximum. It still has
+         * to be non-negative. The following elements must be 2 characters wide, non-negative,
+         * and less than 60.
+         */
         switch (colonCount) {
-          case 0: // case "m"
+          case 0: /* case "m" */
             minutes = Long.parseLong(duration);
             if (minutes >= 0) {
               return Duration.ofMinutes(minutes);
             }
             break;
-          case 1: // case "h:mm"
+          case 1: /* case "h:mm" */
             i = duration.indexOf(':');
             hours = Long.parseLong(duration.substring(0, i));
             minutes = Long.parseLong(duration.substring(i + 1));
@@ -266,8 +273,7 @@ public static Duration parseOsmDuration(String duration) {
               return Duration.ofHours(hours).plusMinutes(minutes);
             }
             break;
-          default: // case "h:mm:ss"
-            //case 2:
+          default: /* case "h:mm:ss" */
             i = duration.indexOf(':');
             j = duration.indexOf(':', i + 1);
             hours = Long.parseLong(duration.substring(0, i));
@@ -287,14 +293,22 @@ public static Duration parseOsmDuration(String duration) {
             break;
         }
       } catch (NumberFormatException e) {
-        // fallthrough
+        /* fallthrough */
       }
     }
-    throw new DateTimeParseException("bad clock duration", duration, 0);
+    throw new DateTimeParseException("Bad OSM duration", duration, 0);
   }
 
-  public Optional<Duration> getTagAsDuration(String tag, Consumer<String> errorHandler) {
-    String value = getTag(tag);
+  /**
+   * Gets a tag's value, assumes it is an OSM wiki spesified duration, parses and returns it.
+   * If parsing fails, calls the error handler.
+   *
+   * @param key
+   * @param errorHandler
+   * @return parsed Duration, or empty
+   */
+  public Optional<Duration> getTagValueAsDuration(String key, Consumer<String> errorHandler) {
+    String value = getTag(key);
     if (value != null) {
       try {
         return Optional.of(parseOsmDuration(value));
diff --git a/application/src/main/java/org/opentripplanner/routing/api/request/preference/EscalatorPreferences.java b/application/src/main/java/org/opentripplanner/routing/api/request/preference/EscalatorPreferences.java
new file mode 100644
index 00000000000..9a770d99fda
--- /dev/null
+++ b/application/src/main/java/org/opentripplanner/routing/api/request/preference/EscalatorPreferences.java
@@ -0,0 +1,109 @@
+package org.opentripplanner.routing.api.request.preference;
+
+import static org.opentripplanner.utils.lang.DoubleUtils.doubleEquals;
+
+import java.io.Serializable;
+import java.util.Objects;
+import java.util.function.Consumer;
+import org.opentripplanner.utils.tostring.ToStringBuilder;
+
+public class EscalatorPreferences implements Serializable {
+
+  public static final EscalatorPreferences DEFAULT = new EscalatorPreferences();
+
+  private final double reluctance;
+  private final double speed;
+
+  private EscalatorPreferences() {
+    this.reluctance = 1.5;
+    this.speed = 0.45;
+  }
+
+  private EscalatorPreferences(Builder builder) {
+    reluctance = builder.reluctance;
+    speed = builder.speed;
+  }
+
+  public static Builder of() {
+    return new Builder(DEFAULT);
+  }
+
+  public Builder copyOf() {
+    return new Builder(this);
+  }
+
+  public double reluctance() {
+    return reluctance;
+  }
+
+  public double speed() {
+    return speed;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    EscalatorPreferences that = (EscalatorPreferences) o;
+    return (doubleEquals(that.reluctance, reluctance) && doubleEquals(that.speed, speed));
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(speed, reluctance);
+  }
+
+  @Override
+  public String toString() {
+    return ToStringBuilder
+      .of(EscalatorPreferences.class)
+      .addNum("speed", speed, DEFAULT.speed)
+      .addNum("reluctance", reluctance, DEFAULT.reluctance)
+      .toString();
+  }
+
+  public static class Builder {
+
+    private final EscalatorPreferences original;
+    private double reluctance;
+    private double speed;
+
+    public Builder(EscalatorPreferences original) {
+      this.original = original;
+      this.reluctance = original.reluctance;
+      this.speed = original.speed;
+    }
+
+    public EscalatorPreferences original() {
+      return original;
+    }
+
+    public double speed() {
+      return speed;
+    }
+
+    public Builder withSpeed(double speed) {
+      this.speed = speed;
+      return this;
+    }
+
+    public double reluctance() {
+      return reluctance;
+    }
+
+    public Builder withReluctance(double reluctance) {
+      this.reluctance = reluctance;
+      return this;
+    }
+
+    public Builder apply(Consumer<Builder> body) {
+      body.accept(this);
+      return this;
+    }
+
+    public EscalatorPreferences build() {
+      var newObj = new EscalatorPreferences(this);
+      return original.equals(newObj) ? original : newObj;
+    }
+  }
+}
diff --git a/application/src/main/java/org/opentripplanner/routing/api/request/preference/WalkPreferences.java b/application/src/main/java/org/opentripplanner/routing/api/request/preference/WalkPreferences.java
index 87dcc320c83..5bc0a120d32 100644
--- a/application/src/main/java/org/opentripplanner/routing/api/request/preference/WalkPreferences.java
+++ b/application/src/main/java/org/opentripplanner/routing/api/request/preference/WalkPreferences.java
@@ -1,6 +1,7 @@
 package org.opentripplanner.routing.api.request.preference;
 
 import static org.opentripplanner.utils.lang.DoubleUtils.doubleEquals;
+import static org.opentripplanner.utils.lang.ObjectUtils.ifNotNull;
 
 import java.io.Serializable;
 import java.util.Objects;
@@ -29,8 +30,7 @@ public final class WalkPreferences implements Serializable {
   private final double stairsTimeFactor;
   private final double safetyFactor;
 
-  private final double escalatorReluctance;
-  private final double escalatorSpeed;
+  private final EscalatorPreferences escalator;
 
   private WalkPreferences() {
     this.speed = 1.33;
@@ -39,8 +39,7 @@ private WalkPreferences() {
     this.stairsReluctance = 2.0;
     this.stairsTimeFactor = 3.0;
     this.safetyFactor = 1.0;
-    this.escalatorReluctance = 1.5;
-    this.escalatorSpeed = 0.45;
+    this.escalator = EscalatorPreferences.DEFAULT;
   }
 
   private WalkPreferences(Builder builder) {
@@ -50,8 +49,7 @@ private WalkPreferences(Builder builder) {
     this.stairsReluctance = Units.reluctance(builder.stairsReluctance);
     this.stairsTimeFactor = Units.reluctance(builder.stairsTimeFactor);
     this.safetyFactor = Units.reluctance(builder.safetyFactor);
-    this.escalatorReluctance = Units.reluctance(builder.escalatorReluctance);
-    this.escalatorSpeed = Units.speed(builder.escalatorSpeed);
+    this.escalator = builder.escalator;
   }
 
   public static Builder of() {
@@ -111,12 +109,8 @@ public double safetyFactor() {
     return safetyFactor;
   }
 
-  public double escalatorReluctance() {
-    return escalatorReluctance;
-  }
-
-  public double escalatorSpeed() {
-    return escalatorSpeed;
+  public EscalatorPreferences escalator() {
+    return escalator;
   }
 
   @Override
@@ -131,8 +125,7 @@ public boolean equals(Object o) {
       doubleEquals(that.stairsReluctance, stairsReluctance) &&
       doubleEquals(that.stairsTimeFactor, stairsTimeFactor) &&
       doubleEquals(that.safetyFactor, safetyFactor) &&
-      doubleEquals(that.escalatorReluctance, escalatorReluctance) &&
-      doubleEquals(that.escalatorSpeed, escalatorSpeed)
+      escalator.equals(that.escalator)
     );
   }
 
@@ -145,8 +138,7 @@ public int hashCode() {
       stairsReluctance,
       stairsTimeFactor,
       safetyFactor,
-      escalatorReluctance,
-      escalatorSpeed
+      escalator
     );
   }
 
@@ -160,8 +152,7 @@ public String toString() {
       .addNum("stairsReluctance", stairsReluctance, DEFAULT.stairsReluctance)
       .addNum("stairsTimeFactor", stairsTimeFactor, DEFAULT.stairsTimeFactor)
       .addNum("safetyFactor", safetyFactor, DEFAULT.safetyFactor)
-      .addNum("escalatorReluctance", escalatorReluctance, DEFAULT.escalatorReluctance)
-      .addNum("escalatorSpeed", escalatorSpeed, DEFAULT.escalatorSpeed)
+      .addObj("escalator", escalator, DEFAULT.escalator)
       .toString();
   }
 
@@ -175,8 +166,7 @@ public static class Builder {
     private double stairsTimeFactor;
     private double safetyFactor;
 
-    private double escalatorReluctance;
-    private double escalatorSpeed;
+    private EscalatorPreferences escalator;
 
     public Builder(WalkPreferences original) {
       this.original = original;
@@ -186,8 +176,7 @@ public Builder(WalkPreferences original) {
       this.stairsReluctance = original.stairsReluctance;
       this.stairsTimeFactor = original.stairsTimeFactor;
       this.safetyFactor = original.safetyFactor;
-      this.escalatorReluctance = original.escalatorReluctance;
-      this.escalatorSpeed = original.escalatorSpeed;
+      this.escalator = original.escalator;
     }
 
     public WalkPreferences original() {
@@ -254,21 +243,12 @@ public Builder withSafetyFactor(double safetyFactor) {
       return this;
     }
 
-    public double escalatorReluctance() {
-      return escalatorReluctance;
-    }
-
-    public Builder withEscalatorReluctance(double escalatorReluctance) {
-      this.escalatorReluctance = escalatorReluctance;
-      return this;
-    }
-
-    public double escalatorSpeed() {
-      return escalatorSpeed;
+    public EscalatorPreferences escalator() {
+      return escalator;
     }
 
-    public Builder withEscalatorSpeed(double escalatorSpeed) {
-      this.escalatorSpeed = escalatorSpeed;
+    public Builder withEscalator(Consumer<EscalatorPreferences.Builder> body) {
+      this.escalator = ifNotNull(this.escalator, original.escalator).copyOf().apply(body).build();
       return this;
     }
 
diff --git a/application/src/main/java/org/opentripplanner/standalone/config/routerequest/RouteRequestConfig.java b/application/src/main/java/org/opentripplanner/standalone/config/routerequest/RouteRequestConfig.java
index 9f0e0ba17b4..454ab29a68c 100644
--- a/application/src/main/java/org/opentripplanner/standalone/config/routerequest/RouteRequestConfig.java
+++ b/application/src/main/java/org/opentripplanner/standalone/config/routerequest/RouteRequestConfig.java
@@ -26,6 +26,7 @@
 import org.opentripplanner.routing.api.request.preference.AccessEgressPreferences;
 import org.opentripplanner.routing.api.request.preference.BikePreferences;
 import org.opentripplanner.routing.api.request.preference.CarPreferences;
+import org.opentripplanner.routing.api.request.preference.EscalatorPreferences;
 import org.opentripplanner.routing.api.request.preference.RoutingPreferences;
 import org.opentripplanner.routing.api.request.preference.ScooterPreferences;
 import org.opentripplanner.routing.api.request.preference.StreetPreferences;
@@ -737,6 +738,32 @@ private static void mapSystemPreferences(NodeAdapter c, SystemPreferences.Builde
     }
   }
 
+  private static void mapEscalatorPreferences(
+    NodeAdapter root,
+    EscalatorPreferences.Builder escalator
+  ) {
+    var dft = escalator.original();
+    NodeAdapter c = root.of("escalator").since(V2_7).summary("Escalator preferences.").asObject();
+    escalator
+      .withReluctance(
+        c
+          .of("reluctance")
+          .since(V2_4)
+          .summary(
+            "A multiplier for how bad being in an escalator is compared to being in transit for equal lengths of time"
+          )
+          .asDouble(dft.reluctance())
+      )
+      .withSpeed(
+        c
+          .of("speed")
+          .since(V2_7)
+          .summary("How fast does an escalator move horizontally?")
+          .description("Horizontal speed of escalator in m/s.")
+          .asDouble(dft.speed())
+      );
+  }
+
   private static void mapWalkPreferences(NodeAdapter root, WalkPreferences.Builder walk) {
     var dft = walk.original();
     NodeAdapter c = root.of("walk").since(V2_5).summary("Walking preferences.").asObject();
@@ -810,22 +837,6 @@ private static void mapWalkPreferences(NodeAdapter root, WalkPreferences.Builder
           )
           .asDouble(dft.safetyFactor())
       )
-      .withEscalatorReluctance(
-        c
-          .of("escalatorReluctance")
-          .since(V2_4)
-          .summary(
-            "A multiplier for how bad being in an escalator is compared to being in transit for equal lengths of time"
-          )
-          .asDouble(dft.escalatorReluctance())
-      )
-      .withEscalatorSpeed(
-        c
-          .of("escalatorSpeed")
-          .since(V2_7)
-          .summary("How fast does an escalator move horizontally?")
-          .description("Horizontal speed of escalator in m/s.")
-          .asDouble(dft.escalatorSpeed())
-      );
+      .withEscalator(escalator -> mapEscalatorPreferences(c, escalator));
   }
 }
diff --git a/application/src/main/java/org/opentripplanner/street/model/edge/EscalatorEdge.java b/application/src/main/java/org/opentripplanner/street/model/edge/EscalatorEdge.java
index fdfd4ee44b4..d44b67568d6 100644
--- a/application/src/main/java/org/opentripplanner/street/model/edge/EscalatorEdge.java
+++ b/application/src/main/java/org/opentripplanner/street/model/edge/EscalatorEdge.java
@@ -31,11 +31,11 @@ public State[] traverse(State s0) {
       var s1 = s0.edit(this);
       double time;
       if (duration == null) {
-        time = getDistanceMeters() / s0.getPreferences().walk().escalatorSpeed();
+        time = getDistanceMeters() / s0.getPreferences().walk().escalator().speed();
       } else {
         time = duration.toSeconds();
       }
-      s1.incrementWeight(s0.getPreferences().walk().escalatorReluctance() * time);
+      s1.incrementWeight(s0.getPreferences().walk().escalator().reluctance() * time);
       s1.incrementTimeInSeconds((int) Math.round(time));
       s1.incrementWalkDistance(getDistanceMeters());
       return s1.makeStateArray();
diff --git a/application/src/test/java/org/opentripplanner/osm/model/OsmWayTest.java b/application/src/test/java/org/opentripplanner/osm/model/OsmWayTest.java
index 277cda7ac9b..9ac9457a9ec 100644
--- a/application/src/test/java/org/opentripplanner/osm/model/OsmWayTest.java
+++ b/application/src/test/java/org/opentripplanner/osm/model/OsmWayTest.java
@@ -1,13 +1,8 @@
 package org.opentripplanner.osm.model;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.time.Duration;
-import java.util.Optional;
-import java.util.function.Consumer;
 import org.junit.jupiter.api.Test;
 import org.opentripplanner.osm.wayproperty.specifier.WayTestData;
 
diff --git a/application/src/test/java/org/opentripplanner/osm/model/OsmWithTagsTest.java b/application/src/test/java/org/opentripplanner/osm/model/OsmWithTagsTest.java
index 3fe49ded403..84b74b8f655 100644
--- a/application/src/test/java/org/opentripplanner/osm/model/OsmWithTagsTest.java
+++ b/application/src/test/java/org/opentripplanner/osm/model/OsmWithTagsTest.java
@@ -325,7 +325,7 @@ void parseTagAsDuration(String value, Optional<Duration> expected) {
     var way = new OsmWithTags();
     var key = "duration";
     way.addTag(key, value);
-    var duration = way.getTagAsDuration(key, i -> {});
+    var duration = way.getTagValueAsDuration(key, i -> {});
     assertEquals(expected, duration);
   }
 }
diff --git a/application/src/test/java/org/opentripplanner/routing/api/request/preference/WalkPreferencesTest.java b/application/src/test/java/org/opentripplanner/routing/api/request/preference/WalkPreferencesTest.java
index a61a0558bb1..785b130ca7a 100644
--- a/application/src/test/java/org/opentripplanner/routing/api/request/preference/WalkPreferencesTest.java
+++ b/application/src/test/java/org/opentripplanner/routing/api/request/preference/WalkPreferencesTest.java
@@ -88,7 +88,7 @@ void testEqualsAndHashCodeWithNewlyConstructedPreferences() {
       .withReluctance(sameReluctance)
       .withStairsReluctance(sameStairsReluctance)
       .withSafetyFactor(sameSafetyFactor)
-      .withEscalatorReluctance(sameEscalatorReluctance)
+      .withEscalator(escalator -> escalator.withReluctance(sameEscalatorReluctance))
       .withBoardCost(sameBoardCost)
       .build();
     var secondEqual = WalkPreferences
@@ -97,7 +97,7 @@ void testEqualsAndHashCodeWithNewlyConstructedPreferences() {
       .withReluctance(sameReluctance)
       .withStairsReluctance(sameStairsReluctance)
       .withSafetyFactor(sameSafetyFactor)
-      .withEscalatorReluctance(sameEscalatorReluctance)
+      .withEscalator(escalator -> escalator.withReluctance(sameEscalatorReluctance))
       .withBoardCost(sameBoardCost)
       .build();
     assertEqualsAndHashCode(firstEqual, secondEqual);
@@ -110,7 +110,7 @@ void testEqualsAndHashCodeWithNewlyConstructedPreferences() {
       .withReluctance(sameReluctance)
       .withStairsReluctance(sameStairsReluctance)
       .withSafetyFactor(sameSafetyFactor)
-      .withEscalatorReluctance(sameEscalatorReluctance)
+      .withEscalator(escalator -> escalator.withReluctance(sameEscalatorReluctance))
       .withBoardCost(sameBoardCost)
       .build();
     assertNotEqualsAndHashCode(firstEqual, differentSpeedPreferences);
@@ -123,7 +123,7 @@ void testEqualsAndHashCodeWithNewlyConstructedPreferences() {
       .withReluctance(notSameReluctance)
       .withStairsReluctance(sameStairsReluctance)
       .withSafetyFactor(sameSafetyFactor)
-      .withEscalatorReluctance(sameEscalatorReluctance)
+      .withEscalator(escalator -> escalator.withReluctance(sameEscalatorReluctance))
       .withBoardCost(sameBoardCost)
       .build();
     assertNotEqualsAndHashCode(firstEqual, differentReluctancePreferences);
@@ -136,7 +136,7 @@ void testEqualsAndHashCodeWithNewlyConstructedPreferences() {
       .withReluctance(sameReluctance)
       .withStairsReluctance(notSameStairsReluctance)
       .withSafetyFactor(sameSafetyFactor)
-      .withEscalatorReluctance(sameEscalatorReluctance)
+      .withEscalator(escalator -> escalator.withReluctance(sameEscalatorReluctance))
       .withBoardCost(sameBoardCost)
       .build();
     assertNotEqualsAndHashCode(firstEqual, differentStairsReluctancePreferences);
@@ -149,7 +149,7 @@ void testEqualsAndHashCodeWithNewlyConstructedPreferences() {
       .withReluctance(sameReluctance)
       .withStairsReluctance(sameStairsReluctance)
       .withSafetyFactor(notSameSafetyFactor)
-      .withEscalatorReluctance(sameEscalatorReluctance)
+      .withEscalator(escalator -> escalator.withReluctance(sameEscalatorReluctance))
       .withBoardCost(sameBoardCost)
       .build();
     assertNotEqualsAndHashCode(firstEqual, differentSafetyFactorPreferences);
@@ -162,7 +162,7 @@ void testEqualsAndHashCodeWithNewlyConstructedPreferences() {
       .withReluctance(sameReluctance)
       .withStairsReluctance(sameStairsReluctance)
       .withSafetyFactor(sameSafetyFactor)
-      .withEscalatorReluctance(notSameEscalatorReluctance)
+      .withEscalator(escalator -> escalator.withReluctance(notSameEscalatorReluctance))
       .withBoardCost(sameBoardCost)
       .build();
     assertNotEqualsAndHashCode(firstEqual, differentEscalatorReluctancePreferences);
@@ -175,7 +175,7 @@ void testEqualsAndHashCodeWithNewlyConstructedPreferences() {
       .withReluctance(sameReluctance)
       .withStairsReluctance(sameStairsReluctance)
       .withSafetyFactor(sameSafetyFactor)
-      .withEscalatorReluctance(sameEscalatorReluctance)
+      .withEscalator(escalator -> escalator.withReluctance(sameEscalatorReluctance))
       .withBoardCost(notSameBoardCost)
       .build();
     assertNotEqualsAndHashCode(firstEqual, differentBoardCostPreferences);
diff --git a/application/src/test/java/org/opentripplanner/street/model/edge/EscalatorEdgeTest.java b/application/src/test/java/org/opentripplanner/street/model/edge/EscalatorEdgeTest.java
index 25199e373a0..23ae7a567f8 100644
--- a/application/src/test/java/org/opentripplanner/street/model/edge/EscalatorEdgeTest.java
+++ b/application/src/test/java/org/opentripplanner/street/model/edge/EscalatorEdgeTest.java
@@ -31,7 +31,9 @@ void testWalking(double escalatorReluctance, double expectedWeight) {
     var edge = EscalatorEdge.createEscalatorEdge(from, to, 45, null);
     var req = StreetSearchRequest
       .of()
-      .withPreferences(p -> p.withWalk(w -> w.withEscalatorReluctance(escalatorReluctance)))
+      .withPreferences(p ->
+        p.withWalk(w -> w.withEscalator(escalator -> escalator.withReluctance(escalatorReluctance)))
+      )
       .withMode(StreetMode.WALK);
 
     var res = edge.traverse(new State(from, req.build()))[0];
diff --git a/application/src/test/resources/standalone/config/router-config.json b/application/src/test/resources/standalone/config/router-config.json
index 5539ec4de65..e3f5b0caad2 100644
--- a/application/src/test/resources/standalone/config/router-config.json
+++ b/application/src/test/resources/standalone/config/router-config.json
@@ -75,8 +75,10 @@
       "reluctance": 4.0,
       "stairsReluctance": 1.65,
       "boardCost": 600,
-      "escalatorReluctance": 1.5,
-      "escalatorSpeed": 0.45
+      "escalator": {
+        "reluctance": 1.5,
+        "speed": 0.45
+      }
     },
     "waitReluctance": 1.0,
     "otherThanPreferredRoutesPenalty": 300,
diff --git a/doc/user/RouteRequest.md b/doc/user/RouteRequest.md
index c6cdef82c25..5b428ff9175 100644
--- a/doc/user/RouteRequest.md
+++ b/doc/user/RouteRequest.md
@@ -155,13 +155,14 @@ and in the [transferRequests in build-config.json](BuildConfiguration.md#transfe
 |    [routes](#rd_unpreferred_routes)                                                                          |   `feed-scoped-id[]`   | The ids of the routes that incur an extra cost when being used. Format: `FeedId:RouteId`                                                                 | *Optional* |                  |  2.2  |
 | walk                                                                                                         |        `object`        | Walking preferences.                                                                                                                                     | *Optional* |                  |  2.5  |
 |    boardCost                                                                                                 |        `integer`       | Prevents unnecessary transfers by adding a cost for boarding a vehicle. This is the cost that is used when boarding while walking.                       | *Optional* | `600`            |  2.0  |
-|    escalatorReluctance                                                                                       |        `double`        | A multiplier for how bad being in an escalator is compared to being in transit for equal lengths of time                                                 | *Optional* | `1.5`            |  2.4  |
-|    [escalatorSpeed](#rd_walk_escalatorSpeed)                                                                 |        `double`        | How fast does an escalator move horizontally?                                                                                                            | *Optional* | `0.45`           |  2.7  |
 |    [reluctance](#rd_walk_reluctance)                                                                         |        `double`        | A multiplier for how bad walking is, compared to being in transit for equal lengths of time.                                                             | *Optional* | `2.0`            |  2.0  |
 |    [safetyFactor](#rd_walk_safetyFactor)                                                                     |        `double`        | Factor for how much the walk safety is considered in routing.                                                                                            | *Optional* | `1.0`            |  2.2  |
 |    speed                                                                                                     |        `double`        | The user's walking speed in meters/second.                                                                                                               | *Optional* | `1.33`           |  2.0  |
 |    stairsReluctance                                                                                          |        `double`        | Used instead of walkReluctance for stairs.                                                                                                               | *Optional* | `2.0`            |  2.0  |
 |    [stairsTimeFactor](#rd_walk_stairsTimeFactor)                                                             |        `double`        | How much more time does it take to walk a flight of stairs compared to walking a similar horizontal length.                                              | *Optional* | `3.0`            |  2.1  |
+|    escalator                                                                                                 |        `object`        | Escalator preferences.                                                                                                                                   | *Optional* |                  |  2.7  |
+|       reluctance                                                                                             |        `double`        | A multiplier for how bad being in an escalator is compared to being in transit for equal lengths of time                                                 | *Optional* | `1.5`            |  2.4  |
+|       [speed](#rd_walk_escalator_speed)                                                                      |        `double`        | How fast does an escalator move horizontally?                                                                                                            | *Optional* | `0.45`           |  2.7  |
 | wheelchairAccessibility                                                                                      |        `object`        | See [Wheelchair Accessibility](Accessibility.md)                                                                                                         | *Optional* |                  |  2.2  |
 |    enabled                                                                                                   |        `boolean`       | Enable wheelchair accessibility.                                                                                                                         | *Optional* | `false`          |  2.0  |
 |    inaccessibleStreetReluctance                                                                              |        `double`        | The factor to multiply the cost of traversing a street edge that is not wheelchair-accessible.                                                           | *Optional* | `25.0`           |  2.2  |
@@ -1072,15 +1073,6 @@ The ids of the routes that incur an extra cost when being used. Format: `FeedId:
 
 How much cost is added is configured in `unpreferredCost`.
 
-<h3 id="rd_walk_escalatorSpeed">escalatorSpeed</h3>
-
-**Since version:** `2.7` ∙ **Type:** `double` ∙ **Cardinality:** `Optional` ∙ **Default value:** `0.45`   
-**Path:** /routingDefaults/walk 
-
-How fast does an escalator move horizontally?
-
-Horizontal speed of escalator in m/s.
-
 <h3 id="rd_walk_reluctance">reluctance</h3>
 
 **Since version:** `2.0` ∙ **Type:** `double` ∙ **Cardinality:** `Optional` ∙ **Default value:** `2.0`   
@@ -1115,6 +1107,15 @@ Default value is based on: Fujiyama, T., & Tyler, N. (2010). Predicting the walk
 speed of pedestrians on stairs. Transportation Planning and Technology, 33(2), 177–202.
 
 
+<h3 id="rd_walk_escalator_speed">speed</h3>
+
+**Since version:** `2.7` ∙ **Type:** `double` ∙ **Cardinality:** `Optional` ∙ **Default value:** `0.45`   
+**Path:** /routingDefaults/walk/escalator 
+
+How fast does an escalator move horizontally?
+
+Horizontal speed of escalator in m/s.
+
 <h3 id="rd_wheelchairAccessibility_maxSlope">maxSlope</h3>
 
 **Since version:** `2.0` ∙ **Type:** `double` ∙ **Cardinality:** `Optional` ∙ **Default value:** `0.083`   
@@ -1224,8 +1225,10 @@ include stairs as a last result.
       "reluctance" : 4.0,
       "stairsReluctance" : 1.65,
       "boardCost" : 600,
-      "escalatorReluctance" : 1.5,
-      "escalatorSpeed" : 0.45
+      "escalator" : {
+        "reluctance" : 1.5,
+        "speed" : 0.45
+      }
     },
     "waitReluctance" : 1.0,
     "otherThanPreferredRoutesPenalty" : 300,
diff --git a/doc/user/RouterConfiguration.md b/doc/user/RouterConfiguration.md
index 043e4f2f485..7dae97fd74c 100644
--- a/doc/user/RouterConfiguration.md
+++ b/doc/user/RouterConfiguration.md
@@ -528,8 +528,10 @@ Used to group requests when monitoring OTP.
       "reluctance" : 4.0,
       "stairsReluctance" : 1.65,
       "boardCost" : 600,
-      "escalatorReluctance" : 1.5,
-      "escalatorSpeed" : 0.45
+      "escalator" : {
+        "reluctance" : 1.5,
+        "speed" : 0.45
+      }
     },
     "waitReluctance" : 1.0,
     "otherThanPreferredRoutesPenalty" : 300,