diff --git a/IOB-UT-NEXT/Iob/Services/HttpService.cs b/IOB-UT-NEXT/Iob/Services/HttpService.cs
new file mode 100644
index 00000000..0a63f768
--- /dev/null
+++ b/IOB-UT-NEXT/Iob/Services/HttpService.cs
@@ -0,0 +1,308 @@
+using NLog;
+using RestSharp;
+using System;
+using System.Diagnostics;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace IOB_UT_NEXT.Iob.Services
+{
+    /// <summary>
+    /// Servizio dedicato alla gestione delle chiamate HTTP.
+    /// </summary>
+    public class HttpService
+    {
+        /// <summary>
+        /// Effettua chiamata URL e restituisce risultato, SE NON E' in veto send.
+        /// </summary>
+        public static string CallUrl(string url)
+        {
+            if (baseUtils.dtVetoSend < DateTime.Now)
+            {
+                return CallUrlGet(url);
+            }
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Effettua chiamata URL e restituisce risultato con payload.
+        /// </summary>
+        public static string CallUrl(string url, string payload)
+        {
+            if (baseUtils.dtVetoSend < DateTime.Now)
+            {
+                return CallUrlPost(url, payload);
+            }
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// Metodo chiamata URL con POST async.
+        /// </summary>
+        public static async Task<string> CallUrlAsync(string url, string payload, CancellationToken ct = default)
+        {
+            try
+            {
+                Stopwatch sw = Stopwatch.StartNew();
+                var content = new StringContent(payload, Encoding.UTF8, "application/json");
+
+                using (var client = new HttpClient()) // Note: In a real app, use IHttpClientFactory
+                {
+                    HttpResponseMessage response = await client.PostAsync(url, content, ct);
+                    response.EnsureSuccessStatusCode();
+
+                    sw.Stop();
+                    baseUtils.TrackUrlCall(url, sw.Elapsed);
+
+                    return await response.Content.ReadAsStringAsync();
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                return "Canceled";
+            }
+            catch (Exception ex)
+            {
+                return $"Error: {ex.Message}";
+            }
+        }
+
+        /// <summary>
+        /// Metodo chiamata URL con GET async.
+        /// </summary>
+        public static async Task<string> CallUrlAsync(string url, CancellationToken ct = default)
+        {
+            try
+            {
+                Stopwatch sw = Stopwatch.StartNew();
+                using (var client = new HttpClient())
+                {
+                    HttpResponseMessage response = await client.GetAsync(url, ct);
+                    response.EnsureSuccessStatusCode();
+
+                    sw.Stop();
+                    baseUtils.TrackUrlCall(url, sw.Elapsed);
+                    return await response.Content.ReadAsStringAsync();
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                return "Canceled";
+            }
+            catch (Exception ex)
+            {
+                return $"Error: {ex.Message}";
+            }
+        }
+
+        /// <summary>
+        /// Effettua chiamata URL IMMEDIATAMENTE (GET) e restituisce risultato.
+        /// </summary>
+        public static string CallUrlGet(string url)
+        {
+            try
+            {
+                HttpClientHandler handler = new HttpClientHandler();
+                if (url.Contains("10.74.82."))
+                {
+                    handler.ServerCertificateCustomValidationCallback =
+                        HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
+                }
+
+                using (var client = new HttpClient(handler))
+                {
+                    Stopwatch sw = Stopwatch.StartNew();
+                    client.Timeout = TimeSpan.FromMilliseconds(5000);
+                    client.DefaultRequestHeaders.UserAgent.ParseAdd(baseUtils.CRS("appName"));
+
+                    var response = client.GetAsync(url).Result;
+                    string answ = response.Content.ReadAsStringAsync().Result;
+
+                    sw.Stop();
+                    baseUtils.TrackUrlCall(url, sw.Elapsed);
+
+                    return answ;
+                }
+            }
+            catch (Exception exc)
+            {
+                int pauseSendMSec = baseUtils.nextPauseSendMSec;
+                baseUtils.dtVetoSend = DateTime.Now.AddMilliseconds(pauseSendMSec);
+
+                if (baseUtils.logValuePermit(url))
+                {
+                    baseUtils.lg.Error($"CallUrlGet | Errore chiamando {url} | wait {pauseSendMSec} ms{Environment.NewLine}Eccezione:{Environment.NewLine}{exc}");
+                }
+
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// Effettua chiamata IMMEDIATAMENTE URL (POST) e restituisce risultato.
+        /// </summary>
+        public static string CallUrlPost(string url, string payload)
+        {
+            string answ = "";
+            Stopwatch sw = Stopwatch.StartNew();
+
+            try
+            {
+                HttpClientHandler handler = new HttpClientHandler();
+                if (url.Contains("10.74."))
+                {
+                    handler.ServerCertificateCustomValidationCallback =
+                        HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
+                }
+
+                using (var client = new HttpClient(handler))
+                {
+                    client.Timeout = TimeSpan.FromMilliseconds(5000);
+                    client.DefaultRequestHeaders.UserAgent.ParseAdd($"{baseUtils.CRS("appName")}-PAYLOAD");
+
+                    var content = new StringContent(payload, Encoding.UTF8, "application/json");
+                    var response = client.PostAsync(url, content).Result;
+
+                    answ = response.Content.ReadAsStringAsync().Result;
+
+                    if (answ != "OK")
+                    {
+                        if (baseUtils.logValuePermit($"{url}|[{answ}]"))
+                        {
+                            baseUtils.lg.Error($"CallUrlPost | POST fallito | ans: [{answ}]:{Environment.NewLine}- URL{Environment.NewLine}{url}{Environment.NewLine}- payload{Environment.NewLine}{payload}");
+                        }
+                    }
+                }
+            }
+            catch (Exception exc)
+            {
+                int pauseSendMSec = baseUtils.nextPauseSendMSec;
+                baseUtils.dtVetoSend = DateTime.Now.AddMilliseconds(pauseSendMSec);
+
+                if (baseUtils.logValuePermit(url))
+                {
+                    baseUtils.lg.Error($"CallUrlPost | Errore chiamando {url} | wait {pauseSendMSec} ms | Dump Payload:{Environment.NewLine}{payload}{Environment.NewLine}Eccezione:{Environment.NewLine}{exc}");
+                }
+            }
+
+            sw.Stop();
+            baseUtils.TrackUrlCall(url, sw.Elapsed);
+            return answ;
+        }
+
+        /// <summary>
+        /// Effettua chiamata URL tramite RestSharp (GET)
+        /// </summary>
+        public static string ExecCallGet(string url, bool fastCall = false)
+        {
+            string answ = "";
+            Uri uri = new Uri(url);
+            string baseUrl = $"{uri.Scheme}://{uri.Host}{(uri.IsDefaultPort ? "" : $":{uri.Port}")}";
+            string resource = uri.AbsolutePath;
+            RestClientOptions restOptStd = new RestClientOptions
+            {
+                BaseUrl = new Uri(baseUrl),
+                Timeout = TimeSpan.FromSeconds(60)
+            };
+            if (fastCall) restOptStd.Timeout = TimeSpan.FromSeconds(5);
+
+            try
+            {
+                using (var client = new RestClient(restOptStd))
+                {
+                    var actReq = new RestRequest(resource, Method.Get);
+                    var currResp = client.Get(actReq);
+                    if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
+                    {
+                        answ = currResp.Content;
+                    }
+                }
+            }
+            catch (Exception exc)
+            {
+                baseUtils.lg.Error($"Eccezione in ExecCallGet{Environment.NewLine}{exc}");
+            }
+            return answ;
+        }
+
+        /// <summary>
+        /// Effettua chiamata URL tramite RestSharp (POST JSON)
+        /// </summary>
+        public static string ExecCallPostJson(string url, string payload, bool fastCall = false)
+        {
+            string answ = "";
+            Uri uri = new Uri(url);
+            string baseUrl = $"{uri.Scheme}://{uri.Host}{(uri.IsDefaultPort ? "" : $":{uri.Port}")}";
+            string resource = uri.AbsolutePath;
+            RestClientOptions restOptStd = new RestClientOptions
+            {
+                BaseUrl = new Uri(baseUrl),
+                Timeout = TimeSpan.FromSeconds(60)
+            };
+            if (fastCall) restOptStd.Timeout = TimeSpan.FromSeconds(5);
+
+            Stopwatch sw = Stopwatch.StartNew();
+            try
+            {
+                using (var client = new RestClient(restOptStd))
+                {
+                    var actReq = new RestRequest(resource, Method.Post);
+                    actReq.AddJsonBody(payload);
+                    var currResp = client.Post(actReq);
+                    if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
+                    {
+                        answ = currResp.Content;
+                    }
+                }
+            }
+            catch (Exception exc)
+            {
+                baseUtils.lg.Error($"Eccezione in ExecCallPostJson{Environment.NewLine}{exc}");
+            }
+            sw.Stop();
+            baseUtils.TrackUrlCall(url, sw.Elapsed);
+            return answ;
+        }
+
+        /// <summary>
+        /// Effettua chiamata URL tramite RestSharp (POST Plain)
+        /// </summary>
+        public static string ExecCallPostPlain(string url, string payload, bool fastCall = false)
+        {
+            string answ = "";
+            Uri uri = new Uri(url);
+            string baseUrl = $"{uri.Scheme}://{uri.Host}{(uri.IsDefaultPort ? "" : $":{uri.Port}")}";
+            string resource = uri.AbsolutePath;
+            RestClientOptions restOptStd = new RestClientOptions
+            {
+                BaseUrl = new Uri(baseUrl),
+                Timeout = TimeSpan.FromSeconds(60)
+            };
+            if (fastCall) restOptStd.Timeout = TimeSpan.FromSeconds(5);
+
+            Stopwatch sw = Stopwatch.StartNew();
+            try
+            {
+                using (var client = new RestClient(restOptStd))
+                {
+                    var actReq = new RestRequest(resource, Method.Post);
+                    actReq.AddStringBody(payload, ContentType.Plain);
+                    var currResp = client.Post(actReq);
+                    if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
+                    {
+                        answ = currResp.Content;
+                    }
+                }
+            }
+            catch (Exception exc)
+            {
+                baseUtils.lg.Error($"Eccezione in ExecCallPostPlain | rawUrl: {url} {Environment.NewLine}{exc}");
+            }
+            sw.Stop();
+            baseUtils.TrackUrlCall(url, sw.Elapsed);
+            return answ;
+        }
+    }
+}