diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index eeb6903d79..f8afb2eca9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -27,24 +27,25 @@ find_package(Threads)
 ## might occur.
 
 pkg_check_modules(CJSON REQUIRED libcjson>=1.7.14)
-pkg_check_modules(LIBGVM_BASE REQUIRED libgvm_base>=22.23)
-pkg_check_modules(LIBGVM_UTIL REQUIRED libgvm_util>=22.23)
-pkg_check_modules(LIBGVM_OSP REQUIRED libgvm_osp>=22.23)
-pkg_check_modules(LIBGVM_GMP REQUIRED libgvm_gmp>=22.23)
+pkg_check_modules(LIBGVM_BASE REQUIRED libgvm_base>=22.28)
+pkg_check_modules(LIBGVM_UTIL REQUIRED libgvm_util>=22.28)
+pkg_check_modules(LIBGVM_OSP REQUIRED libgvm_osp>=22.28)
+pkg_check_modules(LIBGVM_GMP REQUIRED libgvm_gmp>=22.28)
 if(OPENVASD)
-  pkg_check_modules(LIBGVM_HTTP REQUIRED libgvm_http>=22.23)
-  pkg_check_modules(LIBGVM_OPENVASD REQUIRED libgvm_openvasd>=22.23)
+  pkg_check_modules(LIBGVM_HTTP REQUIRED libgvm_http>=22.28)
+  pkg_check_modules(LIBGVM_HTTP_SCANNER REQUIRED libgvm_http_scanner>=22.28)
+  pkg_check_modules(LIBGVM_OPENVASD REQUIRED libgvm_openvasd>=22.28)
 else(OPENVASD)
   message(STATUS "OPENVASD flag is not enabled")
 endif(OPENVASD)
 if(ENABLE_AGENTS)
   if(NOT OPENVASD)
-    pkg_check_modules(LIBGVM_HTTP REQUIRED libgvm_http>=22.23)
+    pkg_check_modules(LIBGVM_HTTP REQUIRED libgvm_http>=22.28)
   endif(NOT OPENVASD)
   pkg_check_modules(
     LIBGVM_AGENT_CONTROLLER
     REQUIRED
-    libgvm_agent_controller>=22.27
+    libgvm_agent_controller>=22.28
   )
 else(ENABLE_AGENTS)
   message(STATUS "ENABLE_AGENTS flag is not enabled")
@@ -472,6 +473,7 @@ target_link_libraries(
   ${LIBGVM_OPENVASD_LDFLAGS}
   ${LIBGVM_GMP_LDFLAGS}
   ${LIBGVM_HTTP_LDFLAGS}
+  ${LIBGVM_HTTP_SCANNER_LDFLAGS}
   ${LIBICAL_LDFLAGS}
   ${LINKER_HARDENING_FLAGS}
   ${OPT_THEIA_TGT}
@@ -497,6 +499,7 @@ target_link_libraries(
   ${LIBGVM_OSP_LDFLAGS}
   ${LIBGVM_GMP_LDFLAGS}
   ${LIBGVM_HTTP_LDFLAGS}
+  ${LIBGVM_HTTP_SCANNER_LDFLAGS}
   ${LIBICAL_LDFLAGS}
   ${LINKER_HARDENING_FLAGS}
   ${OPT_THEIA_TGT}
@@ -523,6 +526,7 @@ if(ENABLE_AGENTS)
     ${LIBGVM_OSP_LDFLAGS}
     ${LIBGVM_GMP_LDFLAGS}
     ${LIBGVM_HTTP_LDFLAGS}
+    ${LIBGVM_HTTP_SCANNER_LDFLAGS}
     ${LIBICAL_LDFLAGS}
     ${LINKER_HARDENING_FLAGS}
     ${OPT_THEIA_TGT}
@@ -549,6 +553,7 @@ target_link_libraries(
   ${LIBGVM_OSP_LDFLAGS}
   ${LIBGVM_GMP_LDFLAGS}
   ${LIBGVM_HTTP_LDFLAGS}
+  ${LIBGVM_HTTP_SCANNER_LDFLAGS}
   ${LIBICAL_LDFLAGS}
   ${LINKER_HARDENING_FLAGS}
   ${OPT_THEIA_TGT}
@@ -574,6 +579,7 @@ target_link_libraries(
   ${LIBGVM_OPENVASD_LDFLAGS}
   ${LIBGVM_GMP_LDFLAGS}
   ${LIBGVM_HTTP_LDFLAGS}
+  ${LIBGVM_HTTP_SCANNER_LDFLAGS}
   ${LIBICAL_LDFLAGS}
   ${LINKER_HARDENING_FLAGS}
   ${OPT_THEIA_TGT}
@@ -599,6 +605,7 @@ target_link_libraries(
   ${LIBGVM_OPENVASD_LDFLAGS}
   ${LIBGVM_GMP_LDFLAGS}
   ${LIBGVM_HTTP_LDFLAGS}
+  ${LIBGVM_HTTP_SCANNER_LDFLAGS}
   ${LIBICAL_LDFLAGS}
   ${LINKER_HARDENING_FLAGS}
   ${OPT_THEIA_TGT}
@@ -624,6 +631,7 @@ target_link_libraries(
   ${LIBGVM_OPENVASD_LDFLAGS}
   ${LIBGVM_GMP_LDFLAGS}
   ${LIBGVM_HTTP_LDFLAGS}
+  ${LIBGVM_HTTP_SCANNER_LDFLAGS}
   ${LIBICAL_LDFLAGS}
   ${LINKER_HARDENING_FLAGS}
   ${OPT_THEIA_TGT}
@@ -649,6 +657,7 @@ target_link_libraries(
   ${LIBGVM_OPENVASD_LDFLAGS}
   ${LIBGVM_GMP_LDFLAGS}
   ${LIBGVM_HTTP_LDFLAGS}
+  ${LIBGVM_HTTP_SCANNER_LDFLAGS}
   ${LIBICAL_LDFLAGS}
   ${LINKER_HARDENING_FLAGS}
   ${OPT_THEIA_TGT}
diff --git a/src/gmp.c b/src/gmp.c
index 46960cdaf7..3cd2946e28 100644
--- a/src/gmp.c
+++ b/src/gmp.c
@@ -17300,22 +17300,22 @@ send_scanner_info (iterator_t *scanners, gmp_parser_t *gmp_parser,
               nodes = params;
               while (nodes)
                 {
-                  openvasd_param_t *param = nodes->data;
+                  http_scanner_param_t *param = nodes->data;
                   g_warning("<param><id>%s</id><name>%s</name>"
                     "<default>%s</default><description>%s</description>"
                     "<type>osp_%s</type><mandatory>%d</mandatory></param>",
-                    openvasd_param_id (param), openvasd_param_name(param),
-                    openvasd_param_default (param), openvasd_param_desc (param),
-                    openvasd_param_type (param), openvasd_param_mandatory (param));
+                    http_scanner_param_id (param), http_scanner_param_name (param),
+                    http_scanner_param_default (param), http_scanner_param_desc (param),
+                    http_scanner_param_type (param), http_scanner_param_mandatory (param));
                   SENDF_TO_CLIENT_OR_FAIL
                    ("<param><id>%s</id><name>%s</name>"
                     "<default>%s</default><description>%s</description>"
                     "<type>osp_%s</type><mandatory>%d</mandatory></param>",
-                    openvasd_param_id (param), openvasd_param_name(param),
-                    openvasd_param_default (param), openvasd_param_desc (param),
-                    openvasd_param_type (param), 1);
+                    http_scanner_param_id (param), http_scanner_param_name (param),
+                    http_scanner_param_default (param), http_scanner_param_desc (param),
+                    http_scanner_param_type (param), 1);
 
-                  osp_param_free (nodes->data);
+                  http_scanner_param_free (nodes->data);
                   nodes = nodes->next;
                 }
               SENDF_TO_CLIENT_OR_FAIL ("</params></info>");
diff --git a/src/manage.c b/src/manage.c
index 75a0bb52a1..083b6694c4 100644
--- a/src/manage.c
+++ b/src/manage.c
@@ -3038,7 +3038,7 @@ get_osp_performance_string (scanner_t scanner, int start, int end,
                             gchar **error)
 {
 #if OPENVASD
-  openvasd_connector_t connector;
+  http_scanner_connector_t connector;
   int err;
   openvasd_get_performance_opts_t opts;
 
@@ -3056,12 +3056,12 @@ get_osp_performance_string (scanner_t scanner, int start, int end,
   err = openvasd_parsed_performance (connector, opts, performance_str, error);
   if (err)
     {
-      g_warning ("Error getting OSP performance report: %s", *error);
-      openvasd_connector_free (connector);
+      g_warning ("Error getting openvasd performance report: %s", *error);
+      http_scanner_connector_free (connector);
       return 6;
     }
 
-  openvasd_connector_free (connector);
+  http_scanner_connector_free (connector);
 #else
   osp_connect_data_t *conn_data;
   int return_value;
@@ -7100,8 +7100,8 @@ stop_openvasd_task (task_t task)
   report_t previous_report;
 
   scanner_t scanner;
-  openvasd_resp_t response;
-  openvasd_connector_t connector = NULL;
+  http_scanner_resp_t response;
+  http_scanner_connector_t connector = NULL;
 
   scan_report = task_running_report (task);
   if (!scan_report)
@@ -7127,20 +7127,20 @@ stop_openvasd_task (task_t task)
   current_scanner_task = task;
   global_current_report = task_running_report (task);
   set_task_run_status (task, TASK_STATUS_STOP_REQUESTED);
-  response = openvasd_stop_scan (connector);
+  response = http_scanner_stop_scan (connector);
   if (response->code < 0)
     {
       ret = -1;
-      openvasd_response_cleanup (response);
+      http_scanner_response_cleanup (response);
       g_free (scan_id);
       goto end_stop_openvasd;
     }
-  openvasd_response_cleanup (response);
-  response = openvasd_delete_scan (connector);
-  openvasd_response_cleanup (response);
+  http_scanner_response_cleanup (response);
+  response = http_scanner_delete_scan (connector);
+  http_scanner_response_cleanup (response);
   g_free (scan_id);
 end_stop_openvasd:
-  openvasd_connector_free (connector);
+  http_scanner_connector_free (connector);
   set_task_end_time_epoch (task, time (NULL));
   set_task_run_status (task, TASK_STATUS_STOPPED);
   if (scan_report)
@@ -7169,8 +7169,8 @@ static int
 prepare_openvasd_scan_for_resume (task_t task, const char *scan_id,
                                   char **error)
 {
-  openvasd_connector_t connection;
-  openvasd_scan_status_t status;
+  http_scanner_connector_t connection;
+  http_scanner_scan_status_t status;
 
   assert (task);
   assert (scan_id);
@@ -7183,101 +7183,101 @@ prepare_openvasd_scan_for_resume (task_t task, const char *scan_id,
       *error = g_strdup ("Could not connect to openvasd Scanner");
       return -1;
     }
-  status = openvasd_parsed_scan_status (connection);
+  status = http_scanner_parsed_scan_status (connection);
 
-  if (status->status == OPENVASD_SCAN_STATUS_ERROR)
+  if (status->status == HTTP_SCANNER_SCAN_STATUS_ERROR)
     {
       if (status->response_code == 404)
         {
           g_debug ("%s: Scan %s not found", __func__, scan_id);
-          openvasd_connector_free (connection);
+          http_scanner_connector_free (connection);
           trim_partial_report (global_current_report);
           return 1;
         }
       g_warning ("%s: Error getting status of scan %s: %ld",
                  __func__, scan_id, status->response_code);
-      openvasd_connector_free (connection);
+      http_scanner_connector_free (connection);
       return -1;
     }
-  else if (status->status == OPENVASD_SCAN_STATUS_RUNNING
-           || status->status == OPENVASD_SCAN_STATUS_REQUESTED)
+  else if (status->status == HTTP_SCANNER_SCAN_STATUS_RUNNING
+           || status->status == HTTP_SCANNER_SCAN_STATUS_REQUESTED)
     {
-      openvasd_resp_t response;
+      http_scanner_resp_t response;
 
       g_debug ("%s: Scan %s queued or running", __func__, scan_id);
       /* It would be possible to simply continue getting the results
        * from the scanner, but gvmd may have crashed while receiving
        * or storing the results, so some may be missing. */
-      response = openvasd_stop_scan (connection);
+      response = http_scanner_stop_scan (connection);
       if (response->code != 204)
         {
           *error = g_strdup_printf ("Failed to stop old report: %ld",
                                     response->code);
-          openvasd_connector_free (connection);
-          openvasd_response_cleanup (response);
+          http_scanner_connector_free (connection);
+          http_scanner_response_cleanup (response);
           return -1;
         }
-      openvasd_response_cleanup (response);
-      response = openvasd_delete_scan (connection);
+      http_scanner_response_cleanup (response);
+      response = http_scanner_delete_scan (connection);
       if (response->code != 204)
         {
           *error = g_strdup_printf ("Failed to delete old report: %ld",
                              response->code);
-          openvasd_response_cleanup (response);
-          openvasd_connector_free (connection);
+          http_scanner_response_cleanup (response);
+          http_scanner_connector_free (connection);
           return -1;
         }
-      openvasd_response_cleanup (response);
-      openvasd_connector_free (connection);
+      http_scanner_response_cleanup (response);
+      http_scanner_connector_free (connection);
       trim_partial_report (global_current_report);
       return 1;
     }
-  else if (status->status == OPENVASD_SCAN_STATUS_SUCCEEDED)
+  else if (status->status == HTTP_SCANNER_SCAN_STATUS_SUCCEEDED)
     {
-      openvasd_resp_t response;
+      http_scanner_resp_t response;
 
       /* OSP can't stop an already finished/interrupted scan,
        * but it must be delete to be resumed. */
       g_debug ("%s: Scan %s finished", __func__, scan_id);
-      response = openvasd_delete_scan (connection);
+      response = http_scanner_delete_scan (connection);
       if (response->code != 204)
         {
           *error = g_strdup_printf ("Failed to delete old report: %ld",
                              response->code);
-          openvasd_response_cleanup (response);
-          openvasd_connector_free (connection);
+          http_scanner_response_cleanup (response);
+          http_scanner_connector_free (connection);
           return -1;
         }
-      openvasd_response_cleanup (response);
-      openvasd_connector_free (connection);
+      http_scanner_response_cleanup (response);
+      http_scanner_connector_free (connection);
       trim_partial_report (global_current_report);
       return 1;
     }
-  else if (status->status == OPENVASD_SCAN_STATUS_STOPPED
-           || status->status == OPENVASD_SCAN_STATUS_FAILED)
+  else if (status->status == HTTP_SCANNER_SCAN_STATUS_STOPPED
+           || status->status == HTTP_SCANNER_SCAN_STATUS_FAILED)
     {
-      openvasd_resp_t response;
+      http_scanner_resp_t response;
 
       g_debug ("%s: Scan %s stopped or interrupted",
                __func__, scan_id);
-      response = openvasd_delete_scan (connection);
+      response = http_scanner_delete_scan (connection);
       if (response->code != 204)
         {
           *error = g_strdup_printf ("Failed to delete old report: %ld",
                              response->code);
-          openvasd_response_cleanup (response);
-          openvasd_connector_free (connection);
+          http_scanner_response_cleanup (response);
+          http_scanner_connector_free (connection);
           return -1;
         }
-      openvasd_response_cleanup (response);
-      openvasd_connector_free (connection);
+      http_scanner_response_cleanup (response);
+      http_scanner_connector_free (connection);
       trim_partial_report (global_current_report);
       return 1;
     }
 
   g_warning ("%s: Unexpected scanner status %d", __func__, status->status);
   *error = g_strdup_printf ("Unexpected scanner status %d", status->status);
-  openvasd_connector_free (connection);
+  http_scanner_connector_free (connection);
 
   return -1;
 }
@@ -7298,7 +7298,7 @@ static int
 launch_openvasd_openvas_task (task_t task, target_t target, const char *scan_id,
                          int from, char **error)
 {
-  openvasd_connector_t connection;
+  http_scanner_connector_t connection;
   char *hosts_str, *ports_str, *exclude_hosts_str, *finished_hosts_str;
   gchar *clean_hosts, *clean_exclude_hosts, *clean_finished_hosts_str;
   int alive_test, reverse_lookup_only, reverse_lookup_unify;
@@ -7310,7 +7310,7 @@ launch_openvasd_openvas_task (task_t task, target_t target, const char *scan_id,
   openvasd_credential_t *snmp_credential;
   gchar *max_checks, *max_hosts, *hosts_ordering;
   GHashTable *scanner_options;
-  openvasd_resp_t response;
+  http_scanner_resp_t response;
   int ret, empty;
   config_t config;
   iterator_t scanner_prefs_iter, families, prefs;
@@ -7584,13 +7584,21 @@ launch_openvasd_openvas_task (task_t task, target_t target, const char *scan_id,
   scan_config =
     openvasd_build_scan_config_json(openvasd_target, scanner_options, vts);
 
-  response = openvasd_start_scan (connection, scan_config);
+  response = http_scanner_create_scan (connection, scan_config, NULL);
+  if (response->code == 201)
+    {
+      http_scanner_response_cleanup (response);
+      response = http_scanner_start_scan (connection);
+    }
+  else
+    g_warning ("%s: Failed to create scan: %ld", __func__, response->code);
+
   openvasd_target_free(openvasd_target);
   // Credentials are freed with target
   g_slist_free_full (vts, (GDestroyNotify) openvasd_vt_single_free);
   g_hash_table_destroy (scanner_options);
   ret = response->code;
-  openvasd_response_cleanup (response);
+  http_scanner_response_cleanup (response);
 
   return ret;
 }
@@ -7612,8 +7620,8 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
   scanner_t scanner;
   gboolean started, queued_status_updated;
   int retry, connection_retry;
-  openvasd_resp_t response;
-  openvasd_connector_t connector;
+  http_scanner_resp_t response;
+  http_scanner_connector_t connector;
 
   scanner = task_scanner (task);
   connector = openvasd_scanner_connect (scanner, scan_id);
@@ -7636,7 +7644,7 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
           break;
         }
 
-      progress = openvasd_get_scan_progress (connector);
+      progress = http_scanner_get_scan_progress (connector);
 
       if (progress < 0 || progress > 100)
         {
@@ -7659,14 +7667,14 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
                               "Erroneous scan progress value", "", "",
                               QOD_DEFAULT, NULL, NULL);
           report_add_result (report, result);
-          response = openvasd_delete_scan(connector);
+          response = http_scanner_delete_scan(connector);
           rc = -1;
           break;
         }
       else
         {
           /* Get the full openvasd report. */
-          progress = openvasd_get_scan_progress (connector);
+          progress = http_scanner_get_scan_progress (connector);
 
           if (progress < 0 || progress > 100)
             {
@@ -7697,13 +7705,14 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
               GSList *results = NULL;
               static unsigned long result_start = 0;
               static unsigned long result_end = -1; // get up to the end
-              openvasd_status_t current_status;
+              http_scanner_status_t current_status;
               time_t start_time, end_time;
-              openvasd_scan_status_t openvasd_scan_status;
+              http_scanner_scan_status_t openvasd_scan_status;
 
               set_report_slave_progress (report, progress);
 
-              openvasd_scan_status = openvasd_parsed_scan_status (connector);
+              openvasd_scan_status
+                = http_scanner_parsed_scan_status (connector);
               start_time = openvasd_scan_status->start_time;
               end_time = openvasd_scan_status->end_time;
               current_status = openvasd_scan_status->status;
@@ -7712,8 +7721,8 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
 
               gvm_sleep (1);
 
-              openvasd_parsed_results (connector, result_start,
-                                       result_end, &results);
+              http_scanner_parsed_results (connector, result_start,
+                                           result_end, &results);
 
               result_start += g_slist_length (results);
 
@@ -7722,9 +7731,9 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
               if (results != NULL)
                 {
                   g_slist_free_full (results,
-                                     (GDestroyNotify) openvasd_result_free);
+                                     (GDestroyNotify) http_scanner_result_free);
                 }
-              if (current_status == OPENVASD_SCAN_STATUS_STORED)
+              if (current_status == HTTP_SCANNER_SCAN_STATUS_STORED)
                 {
                   if (queued_status_updated == FALSE)
                     {
@@ -7734,7 +7743,7 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
                       queued_status_updated = TRUE;
                     }
                 }
-              else if (current_status == OPENVASD_SCAN_STATUS_FAILED)
+              else if (current_status == HTTP_SCANNER_SCAN_STATUS_FAILED)
                 {
                   result_t result = make_osp_result
                     (task, "", "", "",
@@ -7742,12 +7751,12 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
                      "Task interrupted unexpectedly", "", "",
                      QOD_DEFAULT, NULL, NULL);
                   report_add_result (report, result);
-                  response = openvasd_delete_scan (connector);
+                  response = http_scanner_delete_scan (connector);
                   rc = -3;
                   break;
                 }
               else if (progress >= 0 && progress < 100
-                  && current_status == OPENVASD_SCAN_STATUS_STOPPED)
+                  && current_status == HTTP_SCANNER_SCAN_STATUS_STOPPED)
                 {
                   if (retry > 0)
                     {
@@ -7764,18 +7773,18 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
                      "Scan stopped unexpectedly by the server", "", "",
                      QOD_DEFAULT, NULL, NULL);
                   report_add_result (report, result);
-                  response = openvasd_delete_scan (connector);
+                  response = http_scanner_delete_scan (connector);
                   rc = -1;
                   break;
                 }
               else if (progress == 100
-                       && current_status == OPENVASD_SCAN_STATUS_SUCCEEDED)
+                       && current_status == HTTP_SCANNER_SCAN_STATUS_SUCCEEDED)
                 {
-                  response = openvasd_delete_scan (connector);
+                  response = http_scanner_delete_scan (connector);
                   rc = response->code;
                   break;
                 }
-              else if (current_status == OPENVASD_SCAN_STATUS_RUNNING
+              else if (current_status == HTTP_SCANNER_SCAN_STATUS_RUNNING
                        && started == FALSE)
                 {
                   set_task_run_status (task, TASK_STATUS_RUNNING);
@@ -7789,8 +7798,8 @@ handle_openvasd_scan (task_t task, report_t report, const char *scan_id)
       retry = connection_retry;
       gvm_sleep (5);
     }
-  openvasd_response_cleanup (response);
-  openvasd_connector_free(connector);
+  http_scanner_response_cleanup (response);
+  http_scanner_connector_free (connector);
   return rc;
 }
 
diff --git a/src/manage.h b/src/manage.h
index 8ff459ad3b..ddc8f3f012 100644
--- a/src/manage.h
+++ b/src/manage.h
@@ -3775,7 +3775,7 @@ set_vt_verification_collation (const char *);
 #if OPENVASD
 
 /* openvasd Connection */
-openvasd_connector_t
+http_scanner_connector_t
 openvasd_scanner_connect (scanner_t, const char *);
 #endif
 
diff --git a/src/manage_sql.c b/src/manage_sql.c
index ac01ac6340..daf76f70c4 100644
--- a/src/manage_sql.c
+++ b/src/manage_sql.c
@@ -33303,7 +33303,7 @@ openvasd_get_details_from_iterator (iterator_t *iterator, char **desc,
                                GSList **params)
 {
   int port;
-  openvasd_connector_t connection;
+  http_scanner_connector_t connection;
   const char *host, *ca_pub, *key_pub, *key_priv, *protocol;
 
   assert (iterator);
@@ -33319,22 +33319,22 @@ openvasd_get_details_from_iterator (iterator_t *iterator, char **desc,
   else
     protocol = "http";
 
-  connection = openvasd_connector_new ();
+  connection = http_scanner_connector_new ();
 
-  openvasd_connector_builder (connection, OPENVASD_HOST, host);
-  openvasd_connector_builder (connection, OPENVASD_PROTOCOL, protocol);
-  openvasd_connector_builder (connection, OPENVASD_CA_CERT, ca_pub);
-  openvasd_connector_builder (connection, OPENVASD_KEY, key_priv);
-  openvasd_connector_builder (connection, OPENVASD_CERT, key_pub);
-  openvasd_connector_builder (connection, OPENVASD_PORT, (void *) &port);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_HOST, host);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_PROTOCOL, protocol);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_CA_CERT, ca_pub);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_KEY, key_priv);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_CERT, key_pub);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_PORT, (void *) &port);
 
   if (!connection)
     return 1;
 
   *desc = g_strdup_printf("openvasd Sensor on %s://%s:%d", protocol, host, port);
-  if (openvasd_parsed_scans_preferences (connection, params) < 0)
+  if (http_scanner_parsed_scans_preferences (connection, params) < 0)
     return 1;
-  openvasd_connector_free (connection);
+  http_scanner_connector_free (connection);
   return 0;
 }
 #endif
@@ -47706,12 +47706,12 @@ cleanup_ids_for_table (const char *table)
  *
  * @return New connection if success, NULL otherwise.
  */
-openvasd_connector_t
+http_scanner_connector_t
 openvasd_scanner_connect (scanner_t scanner, const char *scan_id)
 {
   gboolean has_relay;
   int port;
-  openvasd_connector_t connection;
+  http_scanner_connector_t connection;
   char *host, *ca_pub, *key_pub, *key_priv;
   const char *protocol;
 
@@ -47729,17 +47729,17 @@ openvasd_scanner_connect (scanner_t scanner, const char *scan_id)
   else
     protocol = "http";
 
-  connection = openvasd_connector_new ();
+  connection = http_scanner_connector_new ();
 
-  openvasd_connector_builder (connection, OPENVASD_HOST, host);
-  openvasd_connector_builder (connection, OPENVASD_CA_CERT, ca_pub);
-  openvasd_connector_builder (connection, OPENVASD_KEY, key_priv);
-  openvasd_connector_builder (connection, OPENVASD_CERT, key_pub);
-  openvasd_connector_builder (connection, OPENVASD_PROTOCOL, protocol);
-  openvasd_connector_builder (connection, OPENVASD_PORT, (void *) &port);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_HOST, host);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_CA_CERT, ca_pub);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_KEY, key_priv);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_CERT, key_pub);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_PROTOCOL, protocol);
+  http_scanner_connector_builder (connection, HTTP_SCANNER_PORT, (void *) &port);
 
   if (scan_id && scan_id[0] != '\0')
-    openvasd_connector_builder (connection, OPENVASD_SCAN_ID, scan_id);
+    http_scanner_connector_builder (connection, HTTP_SCANNER_SCAN_ID, scan_id);
 
   g_free (host);
   g_free (ca_pub);
@@ -47792,7 +47792,7 @@ get_openvasd_nvti_qod (const char *nvti_oid)
  */
 static int
 check_openvasd_result_exists (report_t report, task_t task,
-                              openvasd_result_t res, char **entity_hash_value,
+                              http_scanner_result_t res, char **entity_hash_value,
                               GHashTable *hashed_openvasd_results)
 {
   GString *result_string;
@@ -47924,7 +47924,7 @@ struct report_aux {
 };
 
 static void
-add_openvasd_result_to_report (openvasd_result_t res, gpointer *results_aux)
+add_openvasd_result_to_report (http_scanner_result_t res, gpointer *results_aux)
 {
 
   struct report_aux *rep_aux = *results_aux;
diff --git a/src/manage_sql_nvts_openvasd.c b/src/manage_sql_nvts_openvasd.c
index 231ca5e4a5..0c60953bed 100644
--- a/src/manage_sql_nvts_openvasd.c
+++ b/src/manage_sql_nvts_openvasd.c
@@ -158,7 +158,7 @@ move_buffer_data (struct FILESTREAM *filestream){
  * @return 0 success, 1 VT integrity check failed, -1 error
  */
 static int
-update_nvts_from_openvasd_vts (openvasd_connector_t connector,
+update_nvts_from_openvasd_vts (http_scanner_connector_t connector,
                                const gchar *scanner_feed_version,
                                int rebuild)
 {
@@ -181,7 +181,7 @@ update_nvts_from_openvasd_vts (openvasd_connector_t connector,
   vt_sevs_batch = batch_start (vt_sev_insert_size);
 
   int running = 0;
-  openvasd_resp_t resp;
+  http_scanner_resp_t resp;
   gvm_json_pull_event_t event;
   gvm_json_pull_parser_t parser;
   FILE *stream = NULL;
@@ -191,7 +191,7 @@ update_nvts_from_openvasd_vts (openvasd_connector_t connector,
   resp = openvasd_get_vt_stream_init (connector);
   if (resp->code < 0)
     {
-      openvasd_response_cleanup (resp);
+      http_scanner_response_cleanup (resp);
       g_warning ("%s: failed to get VTs", __func__);
       return -1;
     }
@@ -217,24 +217,24 @@ update_nvts_from_openvasd_vts (openvasd_connector_t connector,
 
   // First run for initial data in the stream
   running = openvasd_get_vt_stream (connector);
-  fwrite (openvasd_vt_stream_str (connector), 1,
-          openvasd_vt_stream_len (connector), stream);
+  fwrite (http_scanner_stream_str (connector), 1,
+          http_scanner_stream_len (connector), stream);
 
-  openvasd_reset_vt_stream (connector);
+  http_scanner_reset_stream (connector);
   int break_flag = 0;
   while (running)
     {
       size_t non_read_count = 0;
       // Ensure a big chunk of data.
       // Realloc is expensive therefore we realloc with bigger chuncks
-      while (running > 0 && openvasd_vt_stream_len (connector) < GVM_JSON_PULL_READ_BUFFER_SIZE * 8)
+      while (running > 0 && http_scanner_stream_len (connector) < GVM_JSON_PULL_READ_BUFFER_SIZE * 8)
           running = openvasd_get_vt_stream (connector);
 
-      if (openvasd_vt_stream_len (connector) > 0)
+      if (http_scanner_stream_len (connector) > 0)
         {
           move_buffer_data (filestream);
-          fwrite (openvasd_vt_stream_str (connector), 1, openvasd_vt_stream_len (connector), stream);
-          openvasd_reset_vt_stream (connector);
+          fwrite (http_scanner_stream_str (connector), 1, http_scanner_stream_len (connector), stream);
+          http_scanner_reset_stream (connector);
         }
 
       non_read_count = filestream->last_write - filestream->last_read;
@@ -250,7 +250,7 @@ update_nvts_from_openvasd_vts (openvasd_connector_t connector,
               gvm_json_pull_parser_cleanup (&parser);
               fclose (stream);
               g_free(nvti);
-              openvasd_response_cleanup (resp);
+              http_scanner_response_cleanup (resp);
               sql_rollback ();
               return -1;
             }
@@ -290,7 +290,7 @@ update_nvts_from_openvasd_vts (openvasd_connector_t connector,
   gvm_json_pull_parser_cleanup (&parser);
   fclose (stream);
 
-  openvasd_response_cleanup (resp);
+  http_scanner_response_cleanup (resp);
 
   batch_end (vt_refs_batch);
   batch_end (vt_sevs_batch);
@@ -316,8 +316,8 @@ int
 update_scanner_preferences_openvasd (scanner_t scan)
 {
   int first;
-  openvasd_resp_t resp;
-  openvasd_connector_t connector = NULL;
+  http_scanner_resp_t resp;
+  http_scanner_connector_t connector = NULL;
   GString *prefs_sql;
   GSList *point;
   GSList *scan_prefs = NULL;
@@ -333,15 +333,15 @@ update_scanner_preferences_openvasd (scanner_t scan)
   resp = openvasd_get_vts (connector);
   if (resp->code != 200)
     {
-      openvasd_response_cleanup (resp);
+      http_scanner_response_cleanup (resp);
       g_warning ("%s: failed to get scanner preferences", __func__);
       return -1;
     }
 
-  openvasd_parsed_scans_preferences (connector, &scan_prefs);
+  http_scanner_parsed_scans_preferences (connector, &scan_prefs);
   g_debug ("There %d scan preferences", g_slist_length (scan_prefs));
-  openvasd_response_cleanup (resp);
-  openvasd_connector_free (connector);
+  http_scanner_response_cleanup (resp);
+  http_scanner_connector_free (connector);
 
   point = scan_prefs;
   first = 1;
@@ -350,12 +350,12 @@ update_scanner_preferences_openvasd (scanner_t scan)
                             " VALUES");
   while (point)
     {
-      openvasd_param_t *param;
+      http_scanner_param_t *param;
       gchar *quoted_name, *quoted_value;
 
       param = point->data;
-      quoted_name = sql_quote (openvasd_param_id (param));
-      quoted_value = sql_quote (openvasd_param_default (param));
+      quoted_name = sql_quote (http_scanner_param_id (param));
+      quoted_value = sql_quote (http_scanner_param_default (param));
 
       g_string_append_printf (prefs_sql,
                               "%s ('%s', '%s')",
@@ -367,7 +367,7 @@ update_scanner_preferences_openvasd (scanner_t scan)
       g_free (quoted_name);
       g_free (quoted_value);
     }
-  g_slist_free_full (scan_prefs, (GDestroyNotify) openvasd_param_free);
+  g_slist_free_full (scan_prefs, (GDestroyNotify) http_scanner_param_free);
 
   g_string_append (prefs_sql,
                    " ON CONFLICT (name)"
@@ -396,7 +396,7 @@ int
 update_nvt_cache_openvasd (gchar *db_feed_version,
                            gchar *scanner_feed_version, int rebuild)
 {
-  openvasd_connector_t connector = NULL;
+  http_scanner_connector_t connector = NULL;
   scanner_t scan;
   time_t old_nvts_last_modified;
   int ret;
@@ -426,7 +426,7 @@ update_nvt_cache_openvasd (gchar *db_feed_version,
 
   ret = update_nvts_from_openvasd_vts (connector, scanner_feed_version, rebuild);
 
-  openvasd_connector_free (connector);
+  http_scanner_connector_free (connector);
 
   if (ret)
     return ret;
@@ -456,8 +456,8 @@ nvts_feed_info_internal_from_openvasd (const gchar *scanner_uuid,
                                        gchar **vts_version)
 {
   scanner_t scan;
-  openvasd_connector_t connector = NULL;
-  openvasd_resp_t resp = NULL;
+  http_scanner_connector_t connector = NULL;
+  http_scanner_resp_t resp = NULL;
   int ret;
 
   if (find_resource_no_acl ("scanner", scanner_uuid, &scan))
@@ -470,7 +470,7 @@ nvts_feed_info_internal_from_openvasd (const gchar *scanner_uuid,
   if (!connector)
     return 1;
 
-  resp = openvasd_get_health_ready (connector);
+  resp = http_scanner_get_health_ready (connector);
   if (resp->code == -1)
     {
       gboolean has_relay = scanner_has_relay (scan);
@@ -487,8 +487,8 @@ nvts_feed_info_internal_from_openvasd (const gchar *scanner_uuid,
       ret = 0;
     }
 
-  openvasd_response_cleanup (resp);
-  openvasd_connector_free (connector);
+  http_scanner_response_cleanup (resp);
+  http_scanner_connector_free (connector);
   return ret;
 }