diff --git a/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java b/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
index e4f20be6a4..b01857adcc 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/ClientProperties.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -405,6 +405,31 @@ public final class ClientProperties {
      */
     public static final String REQUEST_ENTITY_PROCESSING = "jersey.config.client.request.entity.processing";
 
+    /**
+     * Allows for HTTP Expect:100-Continue being handled by the HttpUrlConnector (default Jersey
+     * connector).
+     *
+     * @since 2.32
+     */
+    public static final String EXPECT_100_CONTINUE = "jersey.config.client.request.expect.100.continue.processing";
+
+    /**
+     * Property for threshold size for content length after which Expect:100-Continue header would be applied
+     * before the main request.
+     *
+     * @since 2.32
+     */
+    public static final String
+            EXPECT_100_CONTINUE_THRESHOLD_SIZE = "jersey.config.client.request.expect.100.continue.threshold.size";
+
+    /**
+     * Default threshold size (64kb) after which which Expect:100-Continue header would be applied before
+     * the main request.
+     *
+     * @since 2.32
+     */
+    public static final Long DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE = 65536L;
+
     private ClientProperties() {
         // prevents instantiation
     }
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/ClientRequest.java b/core-client/src/main/java/org/glassfish/jersey/client/ClientRequest.java
index 162dedaa96..012ef337da 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/ClientRequest.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/ClientRequest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -167,7 +167,7 @@ public <T> T resolveProperty(final String name, final T defaultValue) {
 
     private <T> T resolveProperty(final String name, Object defaultValue, final Class<T> type) {
         // Check runtime configuration first
-        Object result = clientConfig.getProperty(name);
+        Object result = getConfiguration().getProperty(name);
         if (result != null) {
             defaultValue = result;
         }
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java b/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java
new file mode 100644
index 0000000000..3af806c994
--- /dev/null
+++ b/core-client/src/main/java/org/glassfish/jersey/client/http/Expect100ContinueFeature.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.client.http;
+
+import org.glassfish.jersey.client.ClientProperties;
+
+import javax.ws.rs.core.Feature;
+import javax.ws.rs.core.FeatureContext;
+
+public class Expect100ContinueFeature implements Feature {
+
+    private long thresholdSize;
+
+    public Expect100ContinueFeature() {
+        this(ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE);
+    }
+
+    private Expect100ContinueFeature(long thresholdSize) {
+        this.thresholdSize = thresholdSize;
+    }
+
+    /**
+     * Creates Expect100ContinueFeature with custom (not default) threshold size for content length.
+     *
+     * @param thresholdSize size of threshold
+     * @return Expect100Continue Feature
+     */
+    public static Expect100ContinueFeature withCustomThreshold(long thresholdSize) {
+        return new Expect100ContinueFeature(thresholdSize);
+    }
+
+    /**
+     * Creates Expect100Continue Feature with default threshold size
+     *
+     * @return Expect100Continue Feature
+     */
+    public static Expect100ContinueFeature basic() {
+        return new Expect100ContinueFeature();
+    }
+
+    @Override
+    public boolean configure(FeatureContext configurableContext) {
+        if (configurableContext.getConfiguration().getProperty(
+                ClientProperties.EXPECT_100_CONTINUE) == null) {
+            configurableContext.property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE);
+        } else {
+            return false; //Expect:100-Continue handling is already done via property config
+        }
+        if (configurableContext.getConfiguration().getProperty(
+                ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE) == null) {
+            configurableContext.property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, thresholdSize);
+        }
+        return true;
+    }
+
+}
\ No newline at end of file
diff --git a/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java b/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
index a4255a7f7c..0f0614c519 100644
--- a/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
+++ b/core-client/src/main/java/org/glassfish/jersey/client/internal/HttpUrlConnector.java
@@ -334,8 +334,9 @@ private ClientResponse _apply(final ClientRequest request) throws IOException {
                 RequestEntityProcessing entityProcessing = request.resolveProperty(
                         ClientProperties.REQUEST_ENTITY_PROCESSING, RequestEntityProcessing.class);
 
+                final long length = request.getLengthLong();
+
                 if (entityProcessing == null || entityProcessing != RequestEntityProcessing.BUFFERED) {
-                    final long length = request.getLengthLong();
                     if (fixLengthStreaming && length > 0) {
                         uc.setFixedLengthStreamingMode(length);
                     } else if (entityProcessing == RequestEntityProcessing.CHUNKED) {
@@ -351,6 +352,8 @@ private ClientResponse _apply(final ClientRequest request) throws IOException {
                     }
                 }
 
+                processExpect100Continue(request, uc, length, entityProcessing);
+
                 request.setStreamProvider(contentLength -> {
                     setOutboundHeaders(request.getStringHeaders(), uc);
                     return uc.getOutputStream();
@@ -527,6 +530,26 @@ public Object run() throws NoSuchFieldException,
         }
     }
 
+    private static void processExpect100Continue(ClientRequest request, HttpURLConnection uc,
+                                          long length, RequestEntityProcessing entityProcessing) {
+        final Boolean expectContinueActivated = request.resolveProperty(
+                ClientProperties.EXPECT_100_CONTINUE, Boolean.class);
+        final Long expectContinueSizeThreshold = request.resolveProperty(
+                ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE,
+                ClientProperties.DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE);
+
+        final boolean allowStreaming = length > expectContinueSizeThreshold
+                || entityProcessing == RequestEntityProcessing.CHUNKED;
+
+        if (!Boolean.TRUE.equals(expectContinueActivated)
+                || !("POST".equals(uc.getRequestMethod()) || "PUT".equals(uc.getRequestMethod()))
+                || !allowStreaming
+        ) {
+            return;
+        }
+        uc.setRequestProperty("Expect", "100-Continue");
+    }
+
     @Override
     public String getName() {
         return "HttpUrlConnection " + AccessController.doPrivileged(PropertiesHelper.getSystemProperty("java.version"));
diff --git a/tests/e2e-client/pom.xml b/tests/e2e-client/pom.xml
index 78517271fc..6a58e5256a 100644
--- a/tests/e2e-client/pom.xml
+++ b/tests/e2e-client/pom.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
+    Copyright (c) 2017, 2020 Oracle and/or its affiliates. All rights reserved.
 
     This program and the accompanying materials are made available under the
     terms of the Eclipse Public License v. 2.0, which is available at
@@ -42,6 +42,9 @@
                     <reuseForks>false</reuseForks>
                     <enableAssertions>false</enableAssertions>
                     <skipTests>${skip.e2e}</skipTests>
+                    <systemPropertyVariables>
+                        <sun.net.http.allowRestrictedHeaders>true</sun.net.http.allowRestrictedHeaders>
+                    </systemPropertyVariables>
                 </configuration>
             </plugin>
         </plugins>
diff --git a/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java b/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
new file mode 100644
index 0000000000..1616824478
--- /dev/null
+++ b/tests/e2e-client/src/test/java/org/glassfish/jersey/tests/e2e/client/httpurlconnector/Expect100ContinueTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.tests.e2e.client.httpurlconnector;
+
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.client.ClientProperties;
+import org.glassfish.jersey.client.HttpUrlConnectorProvider;
+import org.glassfish.jersey.client.RequestEntityProcessing;
+import org.glassfish.jersey.client.http.Expect100ContinueFeature;
+import org.glassfish.jersey.server.ResourceConfig;
+import org.glassfish.jersey.test.JerseyTest;
+import org.junit.Test;
+
+import javax.ws.rs.HeaderParam;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.core.Application;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+
+import static org.junit.Assert.assertEquals;
+
+public class Expect100ContinueTest extends JerseyTest {
+
+    private static final String RESOURCE_PATH = "expect";
+    private static final String ENTITY_STRING = "1234567890123456789012345678901234567890123456789012"
+           + "3456789012345678901234567890";
+
+
+    @Path(RESOURCE_PATH)
+    public static class Expect100ContinueResource {
+
+        /**
+         * Disclamer - in tests we do not process 100-Continue response properly, so we operate 204 (no content)
+         * and 200 (ok) response codes in order to distinguish between proper and not proper Expect:100-Continue
+         * request handling.
+         *
+         * @param expect - Header value for Expect
+         *
+         * @return 200 (no expectations), 204 (Expect:100-Continue header processed)
+         */
+        @POST
+        public Response publishResource(@HeaderParam("Expect") String expect) {
+            if ("100-Continue".equalsIgnoreCase(expect)) {
+                return Response.noContent().build();
+            }
+            return Response.ok().build();
+        }
+
+    }
+
+    @Override
+    protected Application configure() {
+        return new ResourceConfig(Expect100ContinueTest.Expect100ContinueResource.class);
+    }
+
+    @Test
+    public void testExpect100Continue() {
+       final Response response =  target(RESOURCE_PATH).request().post(Entity.text(ENTITY_STRING));
+       assertEquals("Expected 200", 200, response.getStatus()); //no Expect header sent - responce OK
+    }
+
+    @Test
+    public void testExpect100ContinueChunked() {
+       final Response response =  target(RESOURCE_PATH).register(Expect100ContinueFeature.basic())
+               .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
+               RequestEntityProcessing.CHUNKED).request().post(Entity.text(ENTITY_STRING));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueBuffered() {
+       final Response response =  target(RESOURCE_PATH).register(Expect100ContinueFeature.basic())
+               .property(ClientProperties.REQUEST_ENTITY_PROCESSING,
+               RequestEntityProcessing.BUFFERED).request().header(HttpHeaders.CONTENT_LENGTH, 67000L)
+               .post(Entity.text(ENTITY_STRING));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueCustomLength() {
+       final Response response =  target(RESOURCE_PATH).register(Expect100ContinueFeature.withCustomThreshold(100L))
+               .request().header(HttpHeaders.CONTENT_LENGTH, 101L)
+               .post(Entity.text(ENTITY_STRING));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueCustomLengthWrong() {
+       final Response response =  target(RESOURCE_PATH).register(Expect100ContinueFeature.withCustomThreshold(100L))
+               .request().header(HttpHeaders.CONTENT_LENGTH, 99L)
+               .post(Entity.text(ENTITY_STRING));
+       assertEquals("Expected 200", 200, response.getStatus()); //Expect header NOT sent - low request size
+    }
+
+    @Test
+    public void testExpect100ContinueCustomLengthProperty() {
+       final Response response =  target(RESOURCE_PATH)
+               .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 555L)
+               .register(Expect100ContinueFeature.basic())
+               .request().header(HttpHeaders.CONTENT_LENGTH, 666L)
+               .post(Entity.text(ENTITY_STRING));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+
+    @Test
+    public void testExpect100ContinueRegisterViaCustomProperty() {
+       final Response response =  target(RESOURCE_PATH)
+               .property(ClientProperties.EXPECT_100_CONTINUE_THRESHOLD_SIZE, 43L)
+               .property(ClientProperties.EXPECT_100_CONTINUE, Boolean.TRUE)
+               .request().header(HttpHeaders.CONTENT_LENGTH, 44L)
+               .post(Entity.text(ENTITY_STRING));
+       assertEquals("Expected 204", 204, response.getStatus()); //Expect header sent - No Content response
+    }
+}