diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index d1ceec2..7e3e153 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -13,11 +13,6 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Build and Test
-        uses: qcastel/github-actions-maven-cmd@master
-        with:
-          maven-args: "clean install -Dmaven.test.skip=true -Ddockerfile.skip -DdockerCompose.skip -Djib.skip"
-
       - name: Release
         uses: qcastel/github-actions-maven-release@master
         with:
diff --git a/pom.xml b/pom.xml
index 79207c6..8f3e795 100644
--- a/pom.xml
+++ b/pom.xml
@@ -26,11 +26,11 @@
   </licenses>
   
   <properties>
-    <java.version>17</java.version>
+    <java.version>21</java.version>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <main.java.package>io.phasetwo.keycloak.events</main.java.package>
     <junit.version>5.8.2</junit.version>
-    <keycloak.version>24.0.3</keycloak.version>
+    <keycloak.version>25.0.0</keycloak.version>
     <lombok.version>1.18.32</lombok.version>
     <auto-service.version>1.1.1</auto-service.version>
     <ossrh.url>https://s01.oss.sonatype.org</ossrh.url>
@@ -123,6 +123,11 @@
           </systemPropertyVariables>
         </configuration>
       </plugin>
+      <plugin> <!-- pretty up the code using google java standards `mvn fmt:format` -->
+        <groupId>com.spotify.fmt</groupId>
+        <artifactId>fmt-maven-plugin</artifactId>
+        <version>2.23</version>
+      </plugin>
     </plugins>
   </build>
   
@@ -262,7 +267,7 @@
     <dependency> <!-- so we can test webhooks for org methods -->
       <groupId>io.phasetwo.keycloak</groupId>
       <artifactId>keycloak-orgs</artifactId>
-      <version>[0.61,)</version>
+      <version>[0.76,)</version>
       <scope>test</scope>
     </dependency>
     <dependency>
diff --git a/src/main/java/io/phasetwo/keycloak/events/HttpSenderEventListenerProvider.java b/src/main/java/io/phasetwo/keycloak/events/HttpSenderEventListenerProvider.java
index 8989125..5afb343 100644
--- a/src/main/java/io/phasetwo/keycloak/events/HttpSenderEventListenerProvider.java
+++ b/src/main/java/io/phasetwo/keycloak/events/HttpSenderEventListenerProvider.java
@@ -12,8 +12,6 @@
 import javax.crypto.Mac;
 import javax.crypto.spec.SecretKeySpec;
 import lombok.extern.jbosslog.JBossLog;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.client.HttpClients;
 import org.keycloak.broker.provider.util.SimpleHttp;
 import org.keycloak.models.KeycloakSession;
 import org.keycloak.util.JsonSerialization;
@@ -71,9 +69,8 @@ protected void send(
       SenderTask task, String targetUri, Optional<String> sharedSecret, Optional<String> algorithm)
       throws SenderException, IOException {
     log.debugf("attempting send to %s", targetUri);
-    try (CloseableHttpClient http = HttpClients.createDefault()) {
-      //      SimpleHttp request = SimpleHttp.doPost(targetUri, session).json(task.getEvent());
-      SimpleHttp request = SimpleHttp.doPost(targetUri, http).json(task.getEvent());
+    try {
+      SimpleHttp request = SimpleHttp.doPost(targetUri, session).json(task.getEvent());
       sharedSecret.ifPresent(
           secret ->
               request.header(
diff --git a/src/main/java/io/phasetwo/keycloak/resources/CorsResource.java b/src/main/java/io/phasetwo/keycloak/resources/CorsResource.java
index 4f61def..f744f97 100644
--- a/src/main/java/io/phasetwo/keycloak/resources/CorsResource.java
+++ b/src/main/java/io/phasetwo/keycloak/resources/CorsResource.java
@@ -4,7 +4,6 @@
 import jakarta.ws.rs.core.Response;
 import lombok.extern.jbosslog.JBossLog;
 import org.keycloak.http.HttpRequest;
-import org.keycloak.http.HttpResponse;
 import org.keycloak.models.KeycloakSession;
 import org.keycloak.services.cors.Cors;
 import org.keycloak.services.resources.admin.AdminAuth;
@@ -28,17 +27,15 @@ public CorsResource(KeycloakSession session, HttpRequest request) {
   @Path("{any:.*}")
   public Response preflight() {
     log.debug("CORS OPTIONS preflight request");
-    return Cors.add(request, Response.ok()).auth().allowedMethods(METHODS).preflight().build();
+    return Cors.builder().auth().allowedMethods(METHODS).preflight().add(Response.ok());
   }
 
   public static void setupCors(KeycloakSession session, AdminAuth auth) {
-    HttpRequest request = session.getContext().getHttpRequest();
-    HttpResponse response = session.getContext().getHttpResponse();
-    Cors.add(request)
+    Cors.builder()
         .allowedOrigins(auth.getToken())
         .allowedMethods(METHODS)
         .exposedHeaders("Location")
         .auth()
-        .build(response);
+        .add();
   }
 }
diff --git a/src/test/java/io/phasetwo/keycloak/Helpers.java b/src/test/java/io/phasetwo/keycloak/Helpers.java
index 3da2dcb..0e3b049 100644
--- a/src/test/java/io/phasetwo/keycloak/Helpers.java
+++ b/src/test/java/io/phasetwo/keycloak/Helpers.java
@@ -16,7 +16,6 @@
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.keycloak.admin.client.Keycloak;
 import org.keycloak.admin.client.resource.RealmResource;
-import org.keycloak.broker.provider.util.SimpleHttp;
 import org.keycloak.representations.idm.RealmEventsConfigRepresentation;
 import org.keycloak.representations.idm.UserRepresentation;
 
@@ -75,8 +74,8 @@ public static String createWebhook(
       rep.setEventTypes(types);
     }
 
-    SimpleHttp.Response response =
-        SimpleHttp.doPost(baseUrl, httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doPost(baseUrl, httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(rep)
             .asResponse();
diff --git a/src/test/java/io/phasetwo/keycloak/LegacySimpleHttp.java b/src/test/java/io/phasetwo/keycloak/LegacySimpleHttp.java
new file mode 100644
index 0000000..cd6a719
--- /dev/null
+++ b/src/test/java/io/phasetwo/keycloak/LegacySimpleHttp.java
@@ -0,0 +1,445 @@
+package io.phasetwo.keycloak;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.StringWriter;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.zip.GZIPInputStream;
+import org.apache.http.Header;
+import org.apache.http.HeaderIterator;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpHeaders;
+import org.apache.http.HttpResponse;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpHead;
+import org.apache.http.client.methods.HttpPatch;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.client.methods.HttpRequestBase;
+import org.apache.http.client.utils.URIBuilder;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.message.BasicNameValuePair;
+import org.keycloak.common.util.Base64;
+import org.keycloak.connections.httpclient.HttpClientProvider;
+import org.keycloak.models.KeycloakSession;
+import org.keycloak.util.JsonSerialization;
+
+/** 24.0.5 version of SimpleHttp */
+public class LegacySimpleHttp {
+
+  private static final ObjectMapper mapper = new ObjectMapper();
+  private static final int UNDEFINED_TIMEOUT = -1;
+
+  private final HttpClient client;
+
+  private final String url;
+  private final String method;
+  private Map<String, String> headers;
+  private Map<String, String> params;
+  private Object entity;
+
+  private int socketTimeOutMillis = UNDEFINED_TIMEOUT;
+
+  private int connectTimeoutMillis = UNDEFINED_TIMEOUT;
+
+  private int connectionRequestTimeoutMillis = UNDEFINED_TIMEOUT;
+
+  private RequestConfig.Builder requestConfigBuilder;
+
+  protected LegacySimpleHttp(String url, String method, HttpClient client) {
+    this.client = client;
+    this.url = url;
+    this.method = method;
+  }
+
+  public static LegacySimpleHttp doDelete(String url, KeycloakSession session) {
+    return doDelete(url, session.getProvider(HttpClientProvider.class).getHttpClient());
+  }
+
+  public static LegacySimpleHttp doDelete(String url, HttpClient client) {
+    return new LegacySimpleHttp(url, "DELETE", client);
+  }
+
+  public static LegacySimpleHttp doGet(String url, KeycloakSession session) {
+    return doGet(url, session.getProvider(HttpClientProvider.class).getHttpClient());
+  }
+
+  public static LegacySimpleHttp doGet(String url, HttpClient client) {
+    return new LegacySimpleHttp(url, "GET", client);
+  }
+
+  public static LegacySimpleHttp doPost(String url, KeycloakSession session) {
+    return doPost(url, session.getProvider(HttpClientProvider.class).getHttpClient());
+  }
+
+  public static LegacySimpleHttp doPost(String url, HttpClient client) {
+    return new LegacySimpleHttp(url, "POST", client);
+  }
+
+  public static LegacySimpleHttp doPut(String url, HttpClient client) {
+    return new LegacySimpleHttp(url, "PUT", client);
+  }
+
+  public static LegacySimpleHttp doHead(String url, HttpClient client) {
+    return new LegacySimpleHttp(url, "HEAD", client);
+  }
+
+  public static LegacySimpleHttp doPatch(String url, HttpClient client) {
+    return new LegacySimpleHttp(url, "PATCH", client);
+  }
+
+  public LegacySimpleHttp header(String name, String value) {
+    if (headers == null) {
+      headers = new HashMap<>();
+    }
+    headers.put(name, value);
+    return this;
+  }
+
+  public String getHeader(String name) {
+    if (headers != null) {
+      return headers.get(name);
+    }
+    return null;
+  }
+
+  public LegacySimpleHttp json(Object entity) {
+    this.entity = entity;
+    return this;
+  }
+
+  public LegacySimpleHttp entity(HttpEntity entity) {
+    this.entity = entity;
+    return this;
+  }
+
+  public LegacySimpleHttp param(String name, String value) {
+    if (params == null) {
+      params = new HashMap<>();
+    }
+    params.put(name, value);
+    return this;
+  }
+
+  public LegacySimpleHttp socketTimeOutMillis(int timeout) {
+    this.socketTimeOutMillis = timeout;
+    return this;
+  }
+
+  public LegacySimpleHttp connectTimeoutMillis(int timeout) {
+    this.connectTimeoutMillis = timeout;
+    return this;
+  }
+
+  public LegacySimpleHttp connectionRequestTimeoutMillis(int timeout) {
+    this.connectionRequestTimeoutMillis = timeout;
+    return this;
+  }
+
+  public LegacySimpleHttp auth(String token) {
+    header("Authorization", "Bearer " + token);
+    return this;
+  }
+
+  public LegacySimpleHttp authBasic(final String username, final String password) {
+    final String basicCredentials = String.format("%s:%s", username, password);
+    header("Authorization", "Basic " + Base64.encodeBytes(basicCredentials.getBytes()));
+    return this;
+  }
+
+  public LegacySimpleHttp acceptJson() {
+    if (headers == null || !headers.containsKey("Accept")) {
+      header("Accept", "application/json");
+    }
+    return this;
+  }
+
+  public JsonNode asJson() throws IOException {
+    if (headers == null || !headers.containsKey("Accept")) {
+      header("Accept", "application/json");
+    }
+    return mapper.readTree(asString());
+  }
+
+  public <T> T asJson(Class<T> type) throws IOException {
+    if (headers == null || !headers.containsKey("Accept")) {
+      header("Accept", "application/json");
+    }
+    return JsonSerialization.readValue(asString(), type);
+  }
+
+  public <T> T asJson(TypeReference<T> type) throws IOException {
+    if (headers == null || !headers.containsKey("Accept")) {
+      header("Accept", "application/json");
+    }
+    return JsonSerialization.readValue(asString(), type);
+  }
+
+  public String asString() throws IOException {
+    return asResponse().asString();
+  }
+
+  public int asStatus() throws IOException {
+    return asResponse().getStatus();
+  }
+
+  public Response asResponse() throws IOException {
+    return makeRequest();
+  }
+
+  private HttpRequestBase createHttpRequest() {
+    switch (method) {
+      case "GET":
+        return new HttpGet(appendParameterToUrl(url));
+      case "DELETE":
+        return new HttpDelete(appendParameterToUrl(url));
+      case "HEAD":
+        return new HttpHead(appendParameterToUrl(url));
+      case "PUT":
+        return new HttpPut(appendParameterToUrl(url));
+      case "PATCH":
+        return new HttpPatch(appendParameterToUrl(url));
+      case "POST":
+        // explicit fall through as we want POST to be the default HTTP method
+      default:
+        return new HttpPost(url);
+    }
+  }
+
+  /**
+   * @return the URL without params
+   */
+  public String getUrl() {
+    return url;
+  }
+
+  private Response makeRequest() throws IOException {
+
+    HttpRequestBase httpRequest = createHttpRequest();
+
+    if (httpRequest instanceof HttpPost
+        || httpRequest instanceof HttpPut
+        || httpRequest instanceof HttpPatch) {
+      if (params != null) {
+        ((HttpEntityEnclosingRequestBase) httpRequest).setEntity(getFormEntityFromParameter());
+      } else if (entity instanceof HttpEntity) {
+        ((HttpEntityEnclosingRequestBase) httpRequest).setEntity((HttpEntity) entity);
+      } else if (entity != null) {
+        if (headers == null || !headers.containsKey(HttpHeaders.CONTENT_TYPE)) {
+          header(HttpHeaders.CONTENT_TYPE, "application/json");
+        }
+        ((HttpEntityEnclosingRequestBase) httpRequest).setEntity(getJsonEntity());
+      } else {
+        throw new IllegalStateException("No content set");
+      }
+    }
+
+    if (headers != null) {
+      for (Map.Entry<String, String> h : headers.entrySet()) {
+        httpRequest.setHeader(h.getKey(), h.getValue());
+      }
+    }
+
+    if (socketTimeOutMillis != UNDEFINED_TIMEOUT) {
+      requestConfigBuilder().setSocketTimeout(socketTimeOutMillis);
+    }
+
+    if (connectTimeoutMillis != UNDEFINED_TIMEOUT) {
+      requestConfigBuilder().setConnectTimeout(connectTimeoutMillis);
+    }
+
+    if (connectionRequestTimeoutMillis != UNDEFINED_TIMEOUT) {
+      requestConfigBuilder().setConnectionRequestTimeout(connectionRequestTimeoutMillis);
+    }
+
+    if (requestConfigBuilder != null) {
+      httpRequest.setConfig(requestConfigBuilder.build());
+    }
+
+    return new Response(client.execute(httpRequest));
+  }
+
+  private RequestConfig.Builder requestConfigBuilder() {
+    if (requestConfigBuilder == null) {
+      requestConfigBuilder = RequestConfig.custom();
+    }
+    return requestConfigBuilder;
+  }
+
+  private URI appendParameterToUrl(String url) {
+    try {
+      URIBuilder uriBuilder = new URIBuilder(url);
+
+      if (params != null) {
+        for (Map.Entry<String, String> p : params.entrySet()) {
+          uriBuilder.setParameter(p.getKey(), p.getValue());
+        }
+      }
+
+      return uriBuilder.build();
+    } catch (URISyntaxException ignored) {
+      return null;
+    }
+  }
+
+  private StringEntity getJsonEntity() throws IOException {
+    return new StringEntity(
+        JsonSerialization.writeValueAsString(entity),
+        ContentType.getByMimeType(headers.get(HttpHeaders.CONTENT_TYPE)));
+  }
+
+  private UrlEncodedFormEntity getFormEntityFromParameter() throws IOException {
+    List<NameValuePair> urlParameters = new ArrayList<>();
+
+    if (params != null) {
+      for (Map.Entry<String, String> p : params.entrySet()) {
+        urlParameters.add(new BasicNameValuePair(p.getKey(), p.getValue()));
+      }
+    }
+
+    return new UrlEncodedFormEntity(urlParameters, StandardCharsets.UTF_8);
+  }
+
+  public static class Response implements AutoCloseable {
+
+    private final HttpResponse response;
+    private int statusCode = -1;
+    private String responseString;
+    private ContentType contentType;
+
+    public Response(HttpResponse response) {
+      this.response = response;
+    }
+
+    private void readResponse() throws IOException {
+      if (statusCode == -1) {
+        statusCode = response.getStatusLine().getStatusCode();
+
+        InputStream is;
+        HttpEntity entity = response.getEntity();
+        if (entity != null) {
+          is = entity.getContent();
+          contentType = ContentType.getOrDefault(entity);
+          Charset charset = contentType.getCharset();
+          try {
+            HeaderIterator it = response.headerIterator();
+            while (it.hasNext()) {
+              Header header = it.nextHeader();
+              if (header.getName().equals("Content-Encoding") && header.getValue().equals("gzip")) {
+                is = new GZIPInputStream(is);
+              }
+            }
+
+            try (InputStreamReader reader =
+                charset == null
+                    ? new InputStreamReader(is, StandardCharsets.UTF_8)
+                    : new InputStreamReader(is, charset)) {
+
+              StringWriter writer = new StringWriter();
+
+              char[] buffer = new char[1024 * 4];
+              for (int n = reader.read(buffer); n != -1; n = reader.read(buffer)) {
+                writer.write(buffer, 0, n);
+              }
+
+              responseString = writer.toString();
+            }
+          } finally {
+            if (is != null) {
+              is.close();
+            }
+          }
+        }
+      }
+    }
+
+    public int getStatus() throws IOException {
+      readResponse();
+      return response.getStatusLine().getStatusCode();
+    }
+
+    public JsonNode asJson() throws IOException {
+      return mapper.readTree(asString());
+    }
+
+    public <T> T asJson(Class<T> type) throws IOException {
+      return JsonSerialization.readValue(asString(), type);
+    }
+
+    public <T> T asJson(TypeReference<T> type) throws IOException {
+      return JsonSerialization.readValue(asString(), type);
+    }
+
+    public String asString() throws IOException {
+      readResponse();
+      return responseString;
+    }
+
+    public String getFirstHeader(String name) throws IOException {
+      readResponse();
+      Header[] headers = response.getHeaders(name);
+
+      if (headers != null && headers.length > 0) {
+        return headers[0].getValue();
+      }
+
+      return null;
+    }
+
+    public List<String> getHeader(String name) throws IOException {
+      readResponse();
+      Header[] headers = response.getHeaders(name);
+
+      if (headers != null && headers.length > 0) {
+        return Stream.of(headers).map(Header::getValue).collect(Collectors.toList());
+      }
+
+      return null;
+    }
+
+    public Header[] getAllHeaders() throws IOException {
+      readResponse();
+      return response.getAllHeaders();
+    }
+
+    public ContentType getContentType() throws IOException {
+      readResponse();
+      return contentType;
+    }
+
+    public Charset getContentTypeCharset() throws IOException {
+      readResponse();
+      if (contentType != null) {
+        Charset charset = contentType.getCharset();
+        if (charset != null) {
+          return charset;
+        }
+      }
+      return StandardCharsets.UTF_8;
+    }
+
+    public void close() throws IOException {
+      readResponse();
+    }
+  }
+}
diff --git a/src/test/java/io/phasetwo/keycloak/resources/EventsResourceTest.java b/src/test/java/io/phasetwo/keycloak/resources/EventsResourceTest.java
index 44793bc..90ea723 100644
--- a/src/test/java/io/phasetwo/keycloak/resources/EventsResourceTest.java
+++ b/src/test/java/io/phasetwo/keycloak/resources/EventsResourceTest.java
@@ -10,6 +10,7 @@
 import com.github.xgp.http.server.Server;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import io.phasetwo.keycloak.LegacySimpleHttp;
 import io.phasetwo.keycloak.representation.RealmAttributeRepresentation;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -19,7 +20,6 @@
 import org.apache.http.impl.client.HttpClients;
 import org.junit.jupiter.api.Test;
 import org.keycloak.admin.client.Keycloak;
-import org.keycloak.broker.provider.util.SimpleHttp;
 
 @JBossLog
 public class EventsResourceTest extends AbstractResourceTest {
@@ -120,8 +120,8 @@ public void testHttpConfiguredEvent() throws Exception {
     rep.setRealm("master");
     rep.setName(key);
     rep.setValue(value);
-    SimpleHttp.Response resp =
-        SimpleHttp.doPost(attributesUrl(), httpClient)
+    LegacySimpleHttp.Response resp =
+        LegacySimpleHttp.doPost(attributesUrl(), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(rep)
             .asResponse();
@@ -147,7 +147,7 @@ public void testHttpConfiguredEvent() throws Exception {
     value = "{ \"targetUri\": \""+targetUri+"\", \"retry\": true }";
     rep.setValue(value);
     resp =
-        SimpleHttp.doPut(attributesUrl() + "/" + urlencode(key), httpClient)
+        LegacySimpleHttp.doPut(attributesUrl() + "/" + urlencode(key), httpClient)
         .auth(keycloak.tokenManager().getAccessTokenString())
         .json(rep)
         .asResponse();
@@ -172,9 +172,9 @@ public void testHttpConfiguredEvent() throws Exception {
     server.stop();
   }
 
-  SimpleHttp.Response sendEvent(Keycloak keycloak, Map<String, String> ev) throws Exception {
-    SimpleHttp.Response resp =
-        SimpleHttp.doPost(eventsUrl(), httpClient)
+  LegacySimpleHttp.Response sendEvent(Keycloak keycloak, Map<String, String> ev) throws Exception {
+    LegacySimpleHttp.Response resp =
+        LegacySimpleHttp.doPost(eventsUrl(), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(ev)
             .asResponse();
diff --git a/src/test/java/io/phasetwo/keycloak/resources/RealmAttributesResourceTest.java b/src/test/java/io/phasetwo/keycloak/resources/RealmAttributesResourceTest.java
index 90ab348..3e0a9b6 100644
--- a/src/test/java/io/phasetwo/keycloak/resources/RealmAttributesResourceTest.java
+++ b/src/test/java/io/phasetwo/keycloak/resources/RealmAttributesResourceTest.java
@@ -6,6 +6,7 @@
 import static org.junit.Assert.assertTrue;
 
 import com.fasterxml.jackson.core.type.TypeReference;
+import io.phasetwo.keycloak.LegacySimpleHttp;
 import io.phasetwo.keycloak.representation.RealmAttributeRepresentation;
 import java.net.URLEncoder;
 import java.util.Map;
@@ -13,7 +14,6 @@
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
 import org.junit.jupiter.api.Test;
-import org.keycloak.broker.provider.util.SimpleHttp;
 
 @JBossLog
 public class RealmAttributesResourceTest extends AbstractResourceTest {
@@ -34,8 +34,8 @@ String urlencode(String u) {
 
   @Test
   public void testGetAttributes() throws Exception {
-    SimpleHttp.Response response =
-        SimpleHttp.doGet(baseUrl(), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doGet(baseUrl(), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     Map<String, RealmAttributeRepresentation> attributes =
@@ -55,8 +55,8 @@ public void testAddGetAttribute() throws Exception {
     rep.setRealm("master");
     rep.setName(key);
     rep.setValue(value);
-    SimpleHttp.Response response =
-        SimpleHttp.doPost(baseUrl(), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doPost(baseUrl(), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(rep)
             .asResponse();
@@ -64,7 +64,7 @@ public void testAddGetAttribute() throws Exception {
     assertThat(response.getFirstHeader("Location"), containsString(key));
 
     response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(200));
@@ -85,8 +85,8 @@ public void testUpdateGetAttribute() throws Exception {
     rep.setRealm("master");
     rep.setName(key);
     rep.setValue(value0);
-    SimpleHttp.Response response =
-        SimpleHttp.doPost(baseUrl(), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doPost(baseUrl(), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(rep)
             .asResponse();
@@ -94,7 +94,7 @@ public void testUpdateGetAttribute() throws Exception {
     assertThat(response.getFirstHeader("Location"), containsString(key));
 
     response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(200));
@@ -106,14 +106,14 @@ public void testUpdateGetAttribute() throws Exception {
 
     rep.setValue(value1);
     response =
-        SimpleHttp.doPut(baseUrl() + "/" + urlencode(key), httpClient)
+        LegacySimpleHttp.doPut(baseUrl() + "/" + urlencode(key), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(rep)
             .asResponse();
     assertThat(response.getStatus(), is(204));
 
     response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(200));
@@ -133,8 +133,8 @@ public void testRemoveAttribute() throws Exception {
     rep.setRealm("master");
     rep.setName(key);
     rep.setValue(value0);
-    SimpleHttp.Response response =
-        SimpleHttp.doPost(baseUrl(), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doPost(baseUrl(), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(rep)
             .asResponse();
@@ -142,7 +142,7 @@ public void testRemoveAttribute() throws Exception {
     assertThat(response.getFirstHeader("Location"), containsString(key));
 
     response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(200));
@@ -153,13 +153,13 @@ public void testRemoveAttribute() throws Exception {
     assertThat(rep.getValue(), is(value0));
 
     response =
-        SimpleHttp.doDelete(baseUrl() + "/" + urlencode(key), httpClient)
+        LegacySimpleHttp.doDelete(baseUrl() + "/" + urlencode(key), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(204));
 
     response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(key), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(404));
diff --git a/src/test/java/io/phasetwo/keycloak/resources/WebhooksResourceTest.java b/src/test/java/io/phasetwo/keycloak/resources/WebhooksResourceTest.java
index c2e7a50..4ef78c7 100644
--- a/src/test/java/io/phasetwo/keycloak/resources/WebhooksResourceTest.java
+++ b/src/test/java/io/phasetwo/keycloak/resources/WebhooksResourceTest.java
@@ -11,6 +11,7 @@
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.github.xgp.http.server.Server;
 import com.google.common.collect.ImmutableSet;
+import io.phasetwo.keycloak.LegacySimpleHttp;
 import io.phasetwo.keycloak.events.HttpSenderEventListenerProvider;
 import io.phasetwo.keycloak.representation.WebhookRepresentation;
 import java.net.URLEncoder;
@@ -24,7 +25,6 @@
 import org.apache.http.impl.client.HttpClients;
 import org.junit.jupiter.api.Test;
 import org.keycloak.admin.client.Keycloak;
-import org.keycloak.broker.provider.util.SimpleHttp;
 import org.keycloak.util.JsonSerialization;
 
 @JBossLog
@@ -49,8 +49,8 @@ public void testAddGetWebhook() throws Exception {
     String url = "https://example.com/testAddGetWebhook";
     String id = createWebhook(keycloak, httpClient, baseUrl(), url, "A3jt6D8lz", null);
 
-    SimpleHttp.Response response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(id), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(200));
@@ -69,7 +69,7 @@ public void testAddGetWebhook() throws Exception {
     assertNull(rep.getSecret());
 
     response =
-        SimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
+        LegacySimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(204));
@@ -92,8 +92,8 @@ public void testAddGetWebhookEventTypes() throws Exception {
             "access.RESET_PASSWORD");
     String id = createWebhook(keycloak, httpClient, baseUrl(), url, "A3jt6D8lz", types);
 
-    SimpleHttp.Response response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(id), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(200));
@@ -110,7 +110,7 @@ public void testAddGetWebhookEventTypes() throws Exception {
     assertNull(rep.getSecret());
 
     response =
-        SimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
+        LegacySimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(204));
@@ -128,15 +128,15 @@ public void testUpdateGetWebhook() throws Exception {
     rep.setSecret(secret);
     rep.setEventTypes(ImmutableSet.of("*"));
 
-    SimpleHttp.Response response =
-        SimpleHttp.doPut(baseUrl() + "/" + urlencode(id), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doPut(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(rep)
             .asResponse();
     assertThat(response.getStatus(), is(204));
 
     response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(id), httpClient)
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(200));
@@ -151,7 +151,7 @@ public void testUpdateGetWebhook() throws Exception {
     assertNull(rep.getSecret());
 
     response =
-        SimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
+        LegacySimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(204));
@@ -168,14 +168,14 @@ public void testRemoveWebhoook() throws Exception {
             "A3jt6D8lz",
             null);
 
-    SimpleHttp.Response response =
-        SimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(204));
 
     response =
-        SimpleHttp.doGet(baseUrl() + "/" + urlencode(id), httpClient)
+        LegacySimpleHttp.doGet(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(404));
@@ -260,8 +260,8 @@ public void testWebhookReceivesEvent() throws Exception {
 
     server.stop();
 
-    SimpleHttp.Response response =
-        SimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doDelete(baseUrl() + "/" + urlencode(id), httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .asResponse();
     assertThat(response.getStatus(), is(204));
@@ -272,8 +272,8 @@ void createOrg(Keycloak keycloak, String name) throws Exception {
     m.put("name", name);
     m.put("realm", "master");
 
-    SimpleHttp.Response response =
-        SimpleHttp.doPost(getAuthUrl() + "/realms/master/orgs", httpClient)
+    LegacySimpleHttp.Response response =
+        LegacySimpleHttp.doPost(getAuthUrl() + "/realms/master/orgs", httpClient)
             .auth(keycloak.tokenManager().getAccessTokenString())
             .json(m)
             .asResponse();