BEGIN:VCARD
VERSION:3.0
N;CHARSET=utf-8;ENCODING=QUOTED-PRINTABLE:Paolo Ramazzina
PHOTO;ENCODING=b;TYPE=:<!DOCTYPE html>
<html class="avada-html-layout-wide avada-html-header-position-top avada-is-100-percent-template" dir="ltr" lang="it-IT" prefix="og: https://ogp.me/ns#" prefix="og: http://ogp.me/ns# fb: http://ogp.me/ns/fb#">
<head>
	<meta http-equiv="X-UA-Compatible" content="IE=edge" />
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
	<meta name="viewport" content="width=device-width, initial-scale=1" />
	<script type="text/javascript" data-cookieconsent="ignore">
	window.dataLayer = window.dataLayer || [];

	function gtag() {
		dataLayer.push(arguments);
	}

	gtag("consent", "default", {
		ad_personalization: "denied",
		ad_storage: "denied",
		ad_user_data: "denied",
		analytics_storage: "denied",
		functionality_storage: "denied",
		personalization_storage: "denied",
		security_storage: "granted",
		wait_for_update: 500,
	});
	gtag("set", "ads_data_redaction", true);
	gtag("set", "url_passthrough", true);
</script>
<script type="text/javascript"
		id="Cookiebot"
		src="https://consent.cookiebot.com/uc.js"
		data-implementation="wp"
		data-cbid="c263e444-8f5e-4fcc-8d67-aefd900a374b"
							data-blockingmode="auto"
	></script>
<title>GasNet Group - Soluzioni innovative per le tue esigenze</title>

		<!-- All in One SEO 4.9.3 - aioseo.com -->
	<meta name="description" content="Da oltre 20 anni, Gas.Net Group Srl è un punto di riferimento nel mondo del software, della sicurezza informatica e della consulenza IT." />
	<meta name="robots" content="max-image-preview:large" />
	<link rel="canonical" href="https://gasnetgroup.it/" />
	<meta name="generator" content="All in One SEO (AIOSEO) 4.9.3" />
		<meta property="og:locale" content="it_IT" />
		<meta property="og:site_name" content="GasNet Group -" />
		<meta property="og:type" content="website" />
		<meta property="og:title" content="GasNet Group - Soluzioni innovative per le tue esigenze" />
		<meta property="og:description" content="Da oltre 20 anni, Gas.Net Group Srl è un punto di riferimento nel mondo del software, della sicurezza informatica e della consulenza IT." />
		<meta property="og:url" content="https://gasnetgroup.it/" />
		<meta name="twitter:card" content="summary_large_image" />
		<meta name="twitter:title" content="GasNet Group - Soluzioni innovative per le tue esigenze" />
		<meta name="twitter:description" content="Da oltre 20 anni, Gas.Net Group Srl è un punto di riferimento nel mondo del software, della sicurezza informatica e della consulenza IT." />
		<script type="application/ld+json" class="aioseo-schema">
			{"@context":"https:\/\/schema.org","@graph":[{"@type":"BreadcrumbList","@id":"https:\/\/gasnetgroup.it\/#breadcrumblist","itemListElement":[{"@type":"ListItem","@id":"https:\/\/gasnetgroup.it#listItem","position":1,"name":"Home"}]},{"@type":"Organization","@id":"https:\/\/gasnetgroup.it\/#organization","name":"GasNet Group","url":"https:\/\/gasnetgroup.it\/"},{"@type":"WebPage","@id":"https:\/\/gasnetgroup.it\/#webpage","url":"https:\/\/gasnetgroup.it\/","name":"GasNet Group - Soluzioni innovative per le tue esigenze","description":"Da oltre 20 anni, Gas.Net Group Srl \u00e8 un punto di riferimento nel mondo del software, della sicurezza informatica e della consulenza IT.","inLanguage":"it-IT","isPartOf":{"@id":"https:\/\/gasnetgroup.it\/#website"},"breadcrumb":{"@id":"https:\/\/gasnetgroup.it\/#breadcrumblist"},"datePublished":"2021-05-12T15:41:37+00:00","dateModified":"2025-03-25T16:03:33+00:00"},{"@type":"WebSite","@id":"https:\/\/gasnetgroup.it\/#website","url":"https:\/\/gasnetgroup.it\/","name":"GasNet Group","inLanguage":"it-IT","publisher":{"@id":"https:\/\/gasnetgroup.it\/#organization"}}]}
		</script>
		<!-- All in One SEO -->

<meta name="dlm-version" content="5.1.7">    <script>
    window.addEventListener('CookiebotOnLoad', function (e) {
        if (typeof Cookiebot !== 'undefined') {
            
            // Block HeyGen Marketing cookies
            if (!Cookiebot.consent.marketing) {
                // Block HeyGen marketing cookies
                document.cookie = 'pacific/MOVIO_SESSION_ID=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.heygen.com';
                document.cookie = 'pacific/SID=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.heygen.com';
                document.cookie = 'x-movio-v-id=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.heygen.com';
                document.cookie = 'x-movio-v-id=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.app.heygen.com';
                
                // Block Jotform marketing cookies
                document.cookie = 'userReferer=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.jotform.com';
            }
            
            // Block HeyGen Statistics cookies
            if (!Cookiebot.consent.statistics) {
                // Block HeyGen PostHog cookies
                document.cookie = 'ph_#_posthog=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.heygen.com';
                document.cookie = 'ph_#_posthog=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.app.heygen.com';
                document.cookie = 'ph_#_primary_window_exists=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.app.heygen.com';
                
                // Block Jotform statistics cookies
                document.cookie = 'guest=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.jotform.com';
            }
        }
    });
    </script>
    <link rel='dns-prefetch' href='//www.googletagmanager.com' />
<link rel='dns-prefetch' href='//use.fontawesome.com' />
<link rel="alternate" type="application/rss+xml" title="GasNet Group &raquo; Feed" href="https://gasnetgroup.it/feed/" />
<link rel="alternate" type="application/rss+xml" title="GasNet Group &raquo; Feed dei commenti" href="https://gasnetgroup.it/comments/feed/" />
								<link rel="icon" href="https://gasnetgroup.it/wp-content/uploads/2023/09/favicon-gasnet-64px.png" type="image/png" />
		
					<!-- Apple Touch Icon -->
						<link rel="apple-touch-icon" sizes="180x180" href="https://gasnetgroup.it/wp-content/uploads/2023/09/favicon-gasnet-180px.png" type="image/png">
		
					<!-- Android Icon -->
						<link rel="icon" sizes="192x192" href="https://gasnetgroup.it/wp-content/uploads/2023/09/favicon-gasnet-192px.png" type="image/png">
		
					<!-- MS Edge Icon -->
						<meta name="msapplication-TileImage" content="https://gasnetgroup.it/wp-content/uploads/2023/09/favicon-gasnet-270px.png" type="image/png">
				<link rel="alternate" title="oEmbed (JSON)" type="application/json+oembed" href="https://gasnetgroup.it/wp-json/oembed/1.0/embed?url=https%3A%2F%2Fgasnetgroup.it%2F" />
<link rel="alternate" title="oEmbed (XML)" type="text/xml+oembed" href="https://gasnetgroup.it/wp-json/oembed/1.0/embed?url=https%3A%2F%2Fgasnetgroup.it%2F&#038;format=xml" />
<style id='wp-img-auto-sizes-contain-inline-css' type='text/css'>
img:is([sizes=auto i],[sizes^="auto," i]){contain-intrinsic-size:3000px 1500px}
/*# sourceURL=wp-img-auto-sizes-contain-inline-css */
</style>
<style id='font-awesome-svg-styles-default-inline-css' type='text/css'>
.svg-inline--fa {
  display: inline-block;
  height: 1em;
  overflow: visible;
  vertical-align: -.125em;
}
/*# sourceURL=font-awesome-svg-styles-default-inline-css */
</style>
<link rel='stylesheet' id='font-awesome-svg-styles-css' href='https://gasnetgroup.it/wp-content/uploads/font-awesome/v6.7.2/css/svg-with-js.css' type='text/css' media='all' />
<style id='font-awesome-svg-styles-inline-css' type='text/css'>
   .wp-block-font-awesome-icon svg::before,
   .wp-rich-text-font-awesome-icon svg::before {content: unset;}
/*# sourceURL=font-awesome-svg-styles-inline-css */
</style>
<style id='global-styles-inline-css' type='text/css'>
:root{--wp--preset--aspect-ratio--square: 1;--wp--preset--aspect-ratio--4-3: 4/3;--wp--preset--aspect-ratio--3-4: 3/4;--wp--preset--aspect-ratio--3-2: 3/2;--wp--preset--aspect-ratio--2-3: 2/3;--wp--preset--aspect-ratio--16-9: 16/9;--wp--preset--aspect-ratio--9-16: 9/16;--wp--preset--color--black: #000000;--wp--preset--color--cyan-bluish-gray: #abb8c3;--wp--preset--color--white: #ffffff;--wp--preset--color--pale-pink: #f78da7;--wp--preset--color--vivid-red: #cf2e2e;--wp--preset--color--luminous-vivid-orange: #ff6900;--wp--preset--color--luminous-vivid-amber: #fcb900;--wp--preset--color--light-green-cyan: #7bdcb5;--wp--preset--color--vivid-green-cyan: #00d084;--wp--preset--color--pale-cyan-blue: #8ed1fc;--wp--preset--color--vivid-cyan-blue: #0693e3;--wp--preset--color--vivid-purple: #9b51e0;--wp--preset--color--awb-color-1: #ffffff;--wp--preset--color--awb-color-2: #f8f8f8;--wp--preset--color--awb-color-3: #e2e3e8;--wp--preset--color--awb-color-4: #e0dede;--wp--preset--color--awb-color-5: #0877a5;--wp--preset--color--awb-color-6: #5a5d62;--wp--preset--color--awb-color-7: #333333;--wp--preset--color--awb-color-8: #24272d;--wp--preset--color--awb-color-custom-1: #84d4e8;--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple: linear-gradient(135deg,rgb(6,147,227) 0%,rgb(155,81,224) 100%);--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan: linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%);--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange: linear-gradient(135deg,rgb(252,185,0) 0%,rgb(255,105,0) 100%);--wp--preset--gradient--luminous-vivid-orange-to-vivid-red: linear-gradient(135deg,rgb(255,105,0) 0%,rgb(207,46,46) 100%);--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray: linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%);--wp--preset--gradient--cool-to-warm-spectrum: linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%);--wp--preset--gradient--blush-light-purple: linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%);--wp--preset--gradient--blush-bordeaux: linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%);--wp--preset--gradient--luminous-dusk: linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%);--wp--preset--gradient--pale-ocean: linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%);--wp--preset--gradient--electric-grass: linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%);--wp--preset--gradient--midnight: linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%);--wp--preset--font-size--small: 11.25px;--wp--preset--font-size--medium: 20px;--wp--preset--font-size--large: 22.5px;--wp--preset--font-size--x-large: 42px;--wp--preset--font-size--normal: 15px;--wp--preset--font-size--xlarge: 30px;--wp--preset--font-size--huge: 45px;--wp--preset--spacing--20: 0.44rem;--wp--preset--spacing--30: 0.67rem;--wp--preset--spacing--40: 1rem;--wp--preset--spacing--50: 1.5rem;--wp--preset--spacing--60: 2.25rem;--wp--preset--spacing--70: 3.38rem;--wp--preset--spacing--80: 5.06rem;--wp--preset--shadow--natural: 6px 6px 9px rgba(0, 0, 0, 0.2);--wp--preset--shadow--deep: 12px 12px 50px rgba(0, 0, 0, 0.4);--wp--preset--shadow--sharp: 6px 6px 0px rgba(0, 0, 0, 0.2);--wp--preset--shadow--outlined: 6px 6px 0px -3px rgb(255, 255, 255), 6px 6px rgb(0, 0, 0);--wp--preset--shadow--crisp: 6px 6px 0px rgb(0, 0, 0);}:where(.is-layout-flex){gap: 0.5em;}:where(.is-layout-grid){gap: 0.5em;}body .is-layout-flex{display: flex;}.is-layout-flex{flex-wrap: wrap;align-items: center;}.is-layout-flex > :is(*, div){margin: 0;}body .is-layout-grid{display: grid;}.is-layout-grid > :is(*, div){margin: 0;}:where(.wp-block-columns.is-layout-flex){gap: 2em;}:where(.wp-block-columns.is-layout-grid){gap: 2em;}:where(.wp-block-post-template.is-layout-flex){gap: 1.25em;}:where(.wp-block-post-template.is-layout-grid){gap: 1.25em;}.has-black-color{color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-color{color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-color{color: var(--wp--preset--color--white) !important;}.has-pale-pink-color{color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-color{color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-color{color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-color{color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-color{color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-color{color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-color{color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-color{color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-color{color: var(--wp--preset--color--vivid-purple) !important;}.has-black-background-color{background-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-background-color{background-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-background-color{background-color: var(--wp--preset--color--white) !important;}.has-pale-pink-background-color{background-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-background-color{background-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-background-color{background-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-background-color{background-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-background-color{background-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-background-color{background-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-background-color{background-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-background-color{background-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-background-color{background-color: var(--wp--preset--color--vivid-purple) !important;}.has-black-border-color{border-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-border-color{border-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-border-color{border-color: var(--wp--preset--color--white) !important;}.has-pale-pink-border-color{border-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-border-color{border-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-border-color{border-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-border-color{border-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-border-color{border-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-border-color{border-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-border-color{border-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-border-color{border-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-border-color{border-color: var(--wp--preset--color--vivid-purple) !important;}.has-vivid-cyan-blue-to-vivid-purple-gradient-background{background: var(--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple) !important;}.has-light-green-cyan-to-vivid-green-cyan-gradient-background{background: var(--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan) !important;}.has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange) !important;}.has-luminous-vivid-orange-to-vivid-red-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-orange-to-vivid-red) !important;}.has-very-light-gray-to-cyan-bluish-gray-gradient-background{background: var(--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray) !important;}.has-cool-to-warm-spectrum-gradient-background{background: var(--wp--preset--gradient--cool-to-warm-spectrum) !important;}.has-blush-light-purple-gradient-background{background: var(--wp--preset--gradient--blush-light-purple) !important;}.has-blush-bordeaux-gradient-background{background: var(--wp--preset--gradient--blush-bordeaux) !important;}.has-luminous-dusk-gradient-background{background: var(--wp--preset--gradient--luminous-dusk) !important;}.has-pale-ocean-gradient-background{background: var(--wp--preset--gradient--pale-ocean) !important;}.has-electric-grass-gradient-background{background: var(--wp--preset--gradient--electric-grass) !important;}.has-midnight-gradient-background{background: var(--wp--preset--gradient--midnight) !important;}.has-small-font-size{font-size: var(--wp--preset--font-size--small) !important;}.has-medium-font-size{font-size: var(--wp--preset--font-size--medium) !important;}.has-large-font-size{font-size: var(--wp--preset--font-size--large) !important;}.has-x-large-font-size{font-size: var(--wp--preset--font-size--x-large) !important;}
/*# sourceURL=global-styles-inline-css */
</style>

<link rel='stylesheet' id='dashicons-css' href='https://gasnetgroup.it/wp-includes/css/dashicons.min.css?ver=43bf7ecd6e2853cf806e9aee417668a4' type='text/css' media='all' />
<link rel='stylesheet' id='admin-bar-css' href='https://gasnetgroup.it/wp-includes/css/admin-bar.min.css?ver=43bf7ecd6e2853cf806e9aee417668a4' type='text/css' media='all' />
<style id='admin-bar-inline-css' type='text/css'>

    /* Hide CanvasJS credits for P404 charts specifically */
    #p404RedirectChart .canvasjs-chart-credit {
        display: none !important;
    }
    
    #p404RedirectChart canvas {
        border-radius: 6px;
    }

    .p404-redirect-adminbar-weekly-title {
        font-weight: bold;
        font-size: 14px;
        color: #fff;
        margin-bottom: 6px;
    }

    #wpadminbar #wp-admin-bar-p404_free_top_button .ab-icon:before {
        content: "\f103";
        color: #dc3545;
        top: 3px;
    }
    
    #wp-admin-bar-p404_free_top_button .ab-item {
        min-width: 80px !important;
        padding: 0px !important;
    }
    
    /* Ensure proper positioning and z-index for P404 dropdown */
    .p404-redirect-adminbar-dropdown-wrap { 
        min-width: 0; 
        padding: 0;
        position: static !important;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button_dropdown {
        position: static !important;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button_dropdown .ab-item {
        padding: 0 !important;
        margin: 0 !important;
    }
    
    .p404-redirect-dropdown-container {
        min-width: 340px;
        padding: 18px 18px 12px 18px;
        background: #23282d !important;
        color: #fff;
        border-radius: 12px;
        box-shadow: 0 8px 32px rgba(0,0,0,0.25);
        margin-top: 10px;
        position: relative !important;
        z-index: 999999 !important;
        display: block !important;
        border: 1px solid #444;
    }
    
    /* Ensure P404 dropdown appears on hover */
    #wpadminbar #wp-admin-bar-p404_free_top_button .p404-redirect-dropdown-container { 
        display: none !important;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button:hover .p404-redirect-dropdown-container { 
        display: block !important;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button:hover #wp-admin-bar-p404_free_top_button_dropdown .p404-redirect-dropdown-container {
        display: block !important;
    }
    
    .p404-redirect-card {
        background: #2c3338;
        border-radius: 8px;
        padding: 18px 18px 12px 18px;
        box-shadow: 0 2px 8px rgba(0,0,0,0.07);
        display: flex;
        flex-direction: column;
        align-items: flex-start;
        border: 1px solid #444;
    }
    
    .p404-redirect-btn {
        display: inline-block;
        background: #dc3545;
        color: #fff !important;
        font-weight: bold;
        padding: 5px 22px;
        border-radius: 8px;
        text-decoration: none;
        font-size: 17px;
        transition: background 0.2s, box-shadow 0.2s;
        margin-top: 8px;
        box-shadow: 0 2px 8px rgba(220,53,69,0.15);
        text-align: center;
        line-height: 1.6;
    }
    
    .p404-redirect-btn:hover {
        background: #c82333;
        color: #fff !important;
        box-shadow: 0 4px 16px rgba(220,53,69,0.25);
    }
    
    /* Prevent conflicts with other admin bar dropdowns */
    #wpadminbar .ab-top-menu > li:hover > .ab-item,
    #wpadminbar .ab-top-menu > li.hover > .ab-item {
        z-index: auto;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button:hover > .ab-item {
        z-index: 999998 !important;
    }
    
/*# sourceURL=admin-bar-inline-css */
</style>
<link rel='stylesheet' id='font-awesome-official-css' href='https://use.fontawesome.com/releases/v6.7.2/css/all.css' type='text/css' media='all' integrity="sha384-nRgPTkuX86pH8yjPJUAFuASXQSSl2/bBUiNV47vSYpKFxHJhbcrGnmlYpYJMeD7a" crossorigin="anonymous" />
<link rel='stylesheet' id='fusion-dynamic-css-css' href='https://gasnetgroup.it/wp-content/uploads/fusion-styles/b166e2c72e3ed1a8f964518cae9e9de8.min.css?ver=3.14.2' type='text/css' media='all' />
<link rel='stylesheet' id='font-awesome-official-v4shim-css' href='https://use.fontawesome.com/releases/v6.7.2/css/v4-shims.css' type='text/css' media='all' integrity="sha384-npPMK6zwqNmU3qyCCxEcWJkLBNYxEFM1nGgSoAWuCCXqVVz0cvwKEMfyTNkOxM2N" crossorigin="anonymous" />

<!-- Snippet del tag Google (gtag.js) aggiunto da Site Kit -->
<!-- Snippet Google Analytics aggiunto da Site Kit -->
<script type="text/javascript" src="https://www.googletagmanager.com/gtag/js?id=GT-NS9ZXDQ" id="google_gtagjs-js" async></script>
<script type="text/javascript" id="google_gtagjs-js-after">
/* <![CDATA[ */
window.dataLayer = window.dataLayer || [];function gtag(){dataLayer.push(arguments);}
gtag("set","linker",{"domains":["gasnetgroup.it"]});
gtag("js", new Date());
gtag("set", "developer_id.dZTNiMT", true);
gtag("config", "GT-NS9ZXDQ");
//# sourceURL=google_gtagjs-js-after
/* ]]> */
</script>
<link rel="https://api.w.org/" href="https://gasnetgroup.it/wp-json/" /><link rel="alternate" title="JSON" type="application/json" href="https://gasnetgroup.it/wp-json/wp/v2/pages/750" /><link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://gasnetgroup.it/xmlrpc.php?rsd" />

<link rel='shortlink' href='https://gasnetgroup.it/' />
<meta name="generator" content="Site Kit by Google 1.172.0" /><!-- HFCM by 99 Robots - Snippet # 2: googleConsentMode di Cookiebot -->
<script>
  // Imposta l'impostazione `googleConsentMode` di Cookiebot su `true`
  window.cookieconsent.options.googleConsentMode = true;

  // Controlla se lo script di reCaptcha imposta cookie che non sono necessari per il funzionamento del servizio
  if (document.querySelector('script[src="https://www.google.com/recaptcha/api.js"]') !== null) {
    // Assegna l'attributo `data-cookieconsent` al tag di script
    document.querySelector('script[src="https://www.google.com/recaptcha/api.js"]').setAttribute('data-cookieconsent', 'preferences,statistics,marketing');
  }
</script>
<!-- /end HFCM by 99 Robots -->
<!-- HFCM by 99 Robots - Snippet # 3: Verifica proprietà Google Search Console -->
<meta name="google-site-verification" content="1ORhh8FekbJ5zWZe8kzoTJTa6CAahFRstHwUQJxJMMs" />
<!-- /end HFCM by 99 Robots -->
<style type="text/css" id="css-fb-visibility">@media screen and (max-width: 640px){.fusion-no-small-visibility{display:none !important;}body .sm-text-align-center{text-align:center !important;}body .sm-text-align-left{text-align:left !important;}body .sm-text-align-right{text-align:right !important;}body .sm-text-align-justify{text-align:justify !important;}body .sm-flex-align-center{justify-content:center !important;}body .sm-flex-align-flex-start{justify-content:flex-start !important;}body .sm-flex-align-flex-end{justify-content:flex-end !important;}body .sm-mx-auto{margin-left:auto !important;margin-right:auto !important;}body .sm-ml-auto{margin-left:auto !important;}body .sm-mr-auto{margin-right:auto !important;}body .fusion-absolute-position-small{position:absolute;width:100%;}.awb-sticky.awb-sticky-small{ position: sticky; top: var(--awb-sticky-offset,0); }}@media screen and (min-width: 641px) and (max-width: 800px){.fusion-no-medium-visibility{display:none !important;}body .md-text-align-center{text-align:center !important;}body .md-text-align-left{text-align:left !important;}body .md-text-align-right{text-align:right !important;}body .md-text-align-justify{text-align:justify !important;}body .md-flex-align-center{justify-content:center !important;}body .md-flex-align-flex-start{justify-content:flex-start !important;}body .md-flex-align-flex-end{justify-content:flex-end !important;}body .md-mx-auto{margin-left:auto !important;margin-right:auto !important;}body .md-ml-auto{margin-left:auto !important;}body .md-mr-auto{margin-right:auto !important;}body .fusion-absolute-position-medium{position:absolute;width:100%;}.awb-sticky.awb-sticky-medium{ position: sticky; top: var(--awb-sticky-offset,0); }}@media screen and (min-width: 801px){.fusion-no-large-visibility{display:none !important;}body .lg-text-align-center{text-align:center !important;}body .lg-text-align-left{text-align:left !important;}body .lg-text-align-right{text-align:right !important;}body .lg-text-align-justify{text-align:justify !important;}body .lg-flex-align-center{justify-content:center !important;}body .lg-flex-align-flex-start{justify-content:flex-start !important;}body .lg-flex-align-flex-end{justify-content:flex-end !important;}body .lg-mx-auto{margin-left:auto !important;margin-right:auto !important;}body .lg-ml-auto{margin-left:auto !important;}body .lg-mr-auto{margin-right:auto !important;}body .fusion-absolute-position-large{position:absolute;width:100%;}.awb-sticky.awb-sticky-large{ position: sticky; top: var(--awb-sticky-offset,0); }}</style>		<style type="text/css" id="wp-custom-css">
			.fusion-form-form-wrapper .fusion-form-field .fusion-form-checkbox input  {
	opacity: 1;
	position: static;
}



.menu-item.bordo-fluo > a {
  color: #00f7ff;
  text-shadow: 0 0 5px #00f7ff, 0 0 10px #00f7ff;
  transition: text-shadow 0.3s ease, color 0.3s ease;
}

.menu-item.bordo-fluo > a:hover {
  text-shadow: 0 0 10px #00f7ff, 0 0 20px #00f7ff;
  color: #a8faff; /* tonalità più chiara per il passaggio hover */
}


/* Accessibilità per icona nel menu */
.accessibility {
    font-size: 30px;
}		</style>
				<script type="text/javascript">
			var doc = document.documentElement;
			doc.setAttribute( 'data-useragent', navigator.userAgent );
		</script>
		
	</head>

<body data-rsssl=1 class="home wp-singular page-template page-template-100-width page-template-100-width-php page page-id-750 wp-theme-Avada fusion-image-hovers fusion-pagination-sizing fusion-button_type-flat fusion-button_span-no fusion-button_gradient-linear avada-image-rollover-circle-yes avada-image-rollover-yes avada-image-rollover-direction-bottom fusion-body ltr fusion-sticky-header no-tablet-sticky-header no-mobile-sticky-header fusion-disable-outline fusion-sub-menu-fade mobile-logo-pos-left layout-wide-mode avada-has-boxed-modal-shadow-none layout-scroll-offset-full avada-has-zero-margin-offset-top fusion-top-header menu-text-align-left mobile-menu-design-modern fusion-show-pagination-text fusion-header-layout-v1 avada-responsive avada-footer-fx-none avada-menu-highlight-style-bar fusion-search-form-classic fusion-main-menu-search-dropdown fusion-avatar-square avada-dropdown-styles avada-blog-layout-large avada-blog-archive-layout-medium avada-header-shadow-no avada-menu-icon-position-left avada-has-megamenu-shadow avada-has-mainmenu-dropdown-divider avada-has-breadcrumb-mobile-hidden avada-has-titlebar-hide avada-has-pagination-padding avada-has-slider-fallback-image avada-flyout-menu-direction-fade avada-ec-views-v1" data-awb-post-id="750">
		<a class="skip-link screen-reader-text" href="#content">Salta al contenuto</a>

	<div id="boxed-wrapper">
		
		<div id="wrapper" class="fusion-wrapper">
			<div id="home" style="position:relative;top:-1px;"></div>
														<div id="sliders-container" class="fusion-slider-visibility fusion-no-small-visibility fusion-no-medium-visibility">
			<div id="fusion-slider-17" data-id="17" class="fusion-slider-container fusion-slider-750" style="height:400px;max-width:100%;">
	<style type="text/css">
		#fusion-slider-17 .flex-direction-nav a {width:63px;height:63px;line-height:63px;font-size:25px;}	</style>
	<div class="fusion-slider-loading">Loading...</div>
		<div class="tfs-slider flexslider main-flex" style="max-width:100%;--typography_sensitivity:1.1;" data-slider_width="100%" data-slider_height="400px" data-full_screen="1" data-parallax="1" data-nav_arrows="0" data-autoplay="0" data-loop="1" data-animation="fade" data-slideshow_speed="7000" data-animation_speed="600" data-slider_content_width="" data-nav_box_width="63px" data-nav_box_height="63px" data-nav_arrow_size="25px" data-typo_sensitivity="1.1" data-typo_factor="1.5" data-slider_indicator="" data-slider_indicator_color="#ffffff" data-orderby="date" data-order="DESC" >
		<ul class="slides" style="max-width:100%;">
															<li class="slide-id-22" data-mute="yes" data-loop="yes" data-autoplay="yes">
					<div class="slide-content-container slide-content-center" style="display: none;">
						<div class="slide-content" style="">
															<div class="heading ">
									<div class="fusion-title-sc-wrapper fusion-block-element" style="">
										<div class="fusion-title title fusion-title-1 sep-underline sep-solid fusion-title-center fusion-title-text fusion-title-size-two" style="--awb-text-color:#ffffff;--awb-margin-bottom:0px;--awb-sep-color:#ffffff;--awb-font-size:70px;"><h2 class="fusion-title-heading title-heading-center fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;font-size:1em;--fontSize:70;line-height:1.2;">Gas.Net Group</h2></div>									</div>
								</div>
																						<div class="caption ">
									<div class="fusion-title-sc-wrapper" style="">
										<div class="fusion-title title fusion-title-2 fusion-sep-none fusion-title-center fusion-title-text fusion-title-size-three" style="--awb-text-color:#ffffff;--awb-margin-bottom:0px;--awb-sep-color:#ffffff;--awb-font-size:22px;"><h3 class="fusion-title-heading title-heading-center fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;font-size:1em;--fontSize:22;--minFontSize:22;line-height:1.2;">Consulenza | Progettazione | Applicazioni | Intelligenza Artificiale</h3></div>									</div>
								</div>
																				</div>
					</div>
																					<div class="mobile_video_image" style="background-image: url('https://gasnetgroup.it/wp-content/uploads/2023/09/Screenshot_233.png');"></div>
																<div class="overlay" style="background-color:rgba(86,86,86,0.4)"></div>
										<div class="background self-hosted-video-bg" style="max-width:100%;height:400px;filter: progid:DXImageTransform.Microsoft.AlphaImageLoader(src='', sizingMethod='scale');" data-imgwidth="">
													<span
								class="fusion-slider-self-hosted-video-placeholder"
								data-ogg=""
								data-webm=""
								data-mp4="https://gasnetgroup.it/wp-content/uploads/2023/09/gasnetgroup-front.mp4"
								muted loop								preload="auto"
							></span>
																							</div>
				</li>
					</ul>
	</div>
</div>
		</div>
				<div class="fusion-tb-header"><div class="fusion-fullwidth fullwidth-box fusion-builder-row-1 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling fusion-sticky-container fusion-custom-z-index" style="--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-z-index:9999;--awb-padding-top:0px;--awb-padding-bottom:0px;--awb-padding-top-small:15px;--awb-padding-bottom-small:15px;--awb-margin-bottom:0px;--awb-min-height:60px;--awb-background-color:var(--awb-color8);--awb-flex-wrap:wrap;" data-transition-offset="100" data-scroll-offset="0" data-sticky-large-visibility="1" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-center fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-0 fusion_builder_column_1_4 1_4 fusion-flex-column fusion-column-inner-bg-wrapper" style="--awb-inner-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:25%;--awb-order-medium:0;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:75%;--awb-order-small:0;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-row fusion-content-nowrap"><div class="fusion-image-element " style="--awb-margin-right:10px;--awb-max-width:250px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><span class=" has-fusion-standard-logo fusion-imageframe imageframe-none imageframe-1 hover-type-none"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/" target="_self"><img decoding="async" src="https://gasnetgroup.it/wp-content/uploads/2023/08/logo-gasnet.group_bianco_70px.png" srcset="https://gasnetgroup.it/wp-content/uploads/2023/08/logo-gasnet.group_bianco_70px.png 1x, 2x" style="max-height:70px;height:auto;" width="154" height="70" class="img-responsive fusion-standard-logo disable-lazyload" alt="GasNet Group Logo" /></a></span></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-1 fusion_builder_column_3_4 3_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:75%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:75%;--awb-order-medium:0;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:25%;--awb-order-small:0;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><nav class="awb-menu awb-menu_row awb-menu_em-hover mobile-mode-collapse-to-button awb-menu_icons-left awb-menu_dc-yes mobile-trigger-fullwidth-off awb-menu_mobile-toggle awb-menu_indent-left mobile-size-full-absolute loading mega-menu-loading awb-menu_desktop awb-menu_dropdown awb-menu_expand-right awb-menu_transition-fade" style="--awb-font-size:var(--awb-typography3-font-size);--awb-gap:45px;--awb-justify-content:flex-end;--awb-items-padding-top:35px;--awb-items-padding-bottom:35px;--awb-border-top:1px;--awb-color:hsla(var(--awb-color7-h),var(--awb-color7-s),calc( var(--awb-color7-l) + 61% ),var(--awb-color7-a));--awb-letter-spacing:var(--awb-typography3-letter-spacing);--awb-active-color:var(--awb-color1);--awb-active-border-top:1px;--awb-active-border-color:var(--awb-color1);--awb-submenu-color:var(--awb-color1);--awb-submenu-bg:var(--awb-color8);--awb-submenu-sep-color:rgba(226,226,226,0);--awb-submenu-active-bg:var(--awb-color5);--awb-submenu-active-color:var(--awb-color1);--awb-submenu-font-size:var(--awb-typography3-font-size);--awb-icons-color:hsla(var(--awb-color7-h),var(--awb-color7-s),calc( var(--awb-color7-l) + 61% ),var(--awb-color7-a));--awb-icons-hover-color:var(--awb-color1);--awb-main-justify-content:flex-start;--awb-mobile-nav-button-align-hor:flex-end;--awb-mobile-bg:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));--awb-mobile-color:var(--awb-color1);--awb-mobile-active-bg:var(--awb-color5);--awb-mobile-active-color:var(--awb-color1);--awb-mobile-trigger-font-size:40px;--awb-trigger-padding-top:0px;--awb-trigger-padding-right:0px;--awb-trigger-padding-bottom:0px;--awb-trigger-padding-left:0px;--awb-mobile-trigger-color:var(--awb-color1);--awb-mobile-trigger-background-color:rgba(255,255,255,0);--awb-mobile-nav-trigger-bottom-margin:15px;--awb-mobile-sep-color:rgba(0,0,0,0);--awb-sticky-min-height:70px;--awb-mobile-justify:flex-start;--awb-mobile-caret-left:auto;--awb-mobile-caret-right:0;--awb-fusion-font-family-typography:var(--awb-typography3-font-family);--awb-fusion-font-weight-typography:var(--awb-typography3-font-weight);--awb-fusion-font-style-typography:var(--awb-typography3-font-style);--awb-fusion-font-family-submenu-typography:var(--awb-typography3-font-family);--awb-fusion-font-weight-submenu-typography:var(--awb-typography3-font-weight);--awb-fusion-font-style-submenu-typography:var(--awb-typography3-font-style);--awb-fusion-font-family-mobile-typography:inherit;--awb-fusion-font-style-mobile-typography:normal;--awb-fusion-font-weight-mobile-typography:400;" aria-label="Menu" data-breakpoint="830" data-count="0" data-transition-type="center" data-transition-time="300" data-expand="right"><button type="button" class="awb-menu__m-toggle awb-menu__m-toggle_no-text" aria-expanded="false" aria-controls="menu-taxi-main-menu"><span class="awb-menu__m-toggle-inner"><span class="collapsed-nav-text"><span class="screen-reader-text">Toggle Navigation</span></span><span class="awb-menu__m-collapse-icon awb-menu__m-collapse-icon_no-text"><span class="awb-menu__m-collapse-icon-open awb-menu__m-collapse-icon-open_no-text architecture-menu"></span><span class="awb-menu__m-collapse-icon-close awb-menu__m-collapse-icon-close_no-text architecture-close"></span></span></span></button><ul id="menu-architecture-main-menu" class="fusion-menu awb-menu__main-ul awb-menu__main-ul_row"><li  id="menu-item-20"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-has-children menu-item-20 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="20"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/chi-siamo/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">CHI SIAMO</span><span class="awb-menu__open-nav-submenu-hover"></span></a><button type="button" aria-label="Open submenu of CHI SIAMO" aria-expanded="false" class="awb-menu__open-nav-submenu_mobile awb-menu__open-nav-submenu_main"></button><ul class="awb-menu__sub-ul awb-menu__sub-ul_main"><li  id="menu-item-1058"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1058 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/certificazioni/" class="awb-menu__sub-a"><span>CERTIFICAZIONI</span></a></li></ul></li><li  id="menu-item-133408"  class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-133408 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="133408"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="#" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">SOLUZIONI</span><span class="awb-menu__open-nav-submenu-hover"></span></a><button type="button" aria-label="Open submenu of SOLUZIONI" aria-expanded="false" class="awb-menu__open-nav-submenu_mobile awb-menu__open-nav-submenu_main"></button><ul class="awb-menu__sub-ul awb-menu__sub-ul_main"><li  id="menu-item-133409"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-133409 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/consulenza-project-management/" class="awb-menu__sub-a"><span>Consulenza &#038; Project management</span></a></li><li  id="menu-item-133410"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-133410 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/progettazione-sicurezza-infrastrutture-it/" class="awb-menu__sub-a"><span>Progettazione &#038; Sicurezza infrastrutture IT</span></a></li><li  id="menu-item-133426"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-133426 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/applicazioni-software/" class="awb-menu__sub-a"><span>Applicazioni Software</span></a></li><li  id="menu-item-133425"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-133425 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/intelligenza-artificiale/" class="awb-menu__sub-a"><span>Intelligenza Artificiale</span></a></li></ul></li><li  id="menu-item-832"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-832 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="832"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/area-clienti/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">AREA CLIENTI</span></a></li><li  id="menu-item-17"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-17 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="17"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/contatti/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">CONTATTI</span></a></li><li  id="menu-item-1377"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1377 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="1377"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/lavora-con-noi/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">LAVORA CON NOI</span></a></li><li  id="menu-item-133401"  class="bordo-fluo menu-item menu-item-type-post_type menu-item-object-page menu-item-133401 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-classes="bordo-fluo" data-item-id="133401"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/staff-ai/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">STAFF AI</span></a></li><li  id="menu-item-133456"  class="accessibility menu-item menu-item-type-custom menu-item-object-custom menu-item-133456 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-classes="accessibility" data-item-id="133456"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  title="Accessibility" target="_blank" rel="noopener noreferrer" href="https://gasnetgroup.it/contattaci-accessibility/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text"><i class="fa-solid fa-universal-access"></i></span></a></li></ul></nav></div></div></div></div>
</div>							
			
						<main id="main" class="clearfix width-100">
				<div class="fusion-row" style="max-width:100%;">
<section id="content" class="full-width">
					<div id="post-750" class="post-750 page type-page status-publish hentry">
			<span class="entry-title rich-snippet-hidden">GasNet Group</span><span class="vcard rich-snippet-hidden"><span class="fn"><a href="https://gasnetgroup.it/author/g4sn3t_4dm1n/" title="Articoli scritti da g4sn3t_4dm1n" rel="author">g4sn3t_4dm1n</a></span></span><span class="updated rich-snippet-hidden">2025-03-25T16:03:33+00:00</span>						<div class="post-content">
				<div class="fusion-fullwidth fullwidth-box fusion-builder-row-2 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-background-position:left top;--awb-border-sizes-top:0;--awb-border-sizes-bottom:0;--awb-border-sizes-left:0;--awb-border-sizes-right:0;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:60px;--awb-padding-bottom:50px;--awb-padding-top-small:29px;--awb-padding-bottom-small:31px;--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-2 fusion_builder_column_1_3 1_3 fusion-flex-column" style="--awb-padding-bottom-small:0px;--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-width-large:33.333333333333%;--awb-margin-top-large:0px;--awb-spacing-right-large:5.76%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:5.76%;--awb-width-medium:100%;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-spacing-right-small:1.92%;--awb-margin-bottom-small:7px;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-3 fusion-sep-none fusion-title-text fusion-title-size-two" style="--awb-margin-bottom:50px;--awb-font-size:36px;"><h2 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;font-size:1em;--fontSize:36;line-height:var(--awb-typography1-line-height);">SOLUZIONI <span style="color: #0877a5;">INNOVATIVE</span></h2></div><div class="fusion-separator" style="align-self: flex-start;margin-right:auto;margin-top:0px;margin-bottom:40px;width:100%;max-width:170px;"><div class="fusion-separator-border sep-single sep-solid" style="--awb-height:20px;--awb-amount:20px;--awb-sep-color:var(--awb-color3);border-color:var(--awb-color3);border-top-width:3px;"></div></div><div class="fusion-text fusion-text-1" style="--awb-font-size:var(--awb-typography2-font-size);--awb-line-height:var(--awb-typography2-line-height);--awb-letter-spacing:var(--awb-typography2-letter-spacing);--awb-text-transform:var(--awb-typography2-text-transform);--awb-text-font-family:var(--awb-typography2-font-family);--awb-text-font-weight:var(--awb-typography2-font-weight);--awb-text-font-style:var(--awb-typography2-font-style);"></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-3 fusion_builder_column_2_3 2_3 fusion-flex-column" style="--awb-padding-top-small:0px;--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-width-large:66.666666666667%;--awb-margin-top-large:0px;--awb-spacing-right-large:2.88%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:3.84%;--awb-width-medium:100%;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-margin-top-small:2px;--awb-spacing-right-small:1.92%;--awb-margin-bottom-small:6px;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-text fusion-text-2" style="--awb-content-alignment:left;--awb-font-size:22px;--awb-line-height:1.9;--awb-letter-spacing:0px;--awb-text-font-family:var(--awb-typography2-font-family);--awb-text-font-weight:var(--awb-typography2-font-weight);--awb-text-font-style:var(--awb-typography2-font-style);"><p>Da oltre 25 anni, <b>Gas.Net Group Srl</b> è un punto di riferimento nel settore IT, offrendo servizi di <b>consulenza</b>, <b>progettazione</b>, <b>applicazioni </b>e soluzioni di <b>intelligenza artificiale</b>. Specializzati in soluzioni digitali per il settore sanitario e il terzo settore, supportiamo le aziende nella trasformazione digitale attraverso un approccio integrato e personalizzato. </p>
</div></div></div></div></div><div class="fusion-bg-parallax" data-bg-align="center center" data-direction="left" data-mute="false" data-opacity="100" data-velocity="-0.7" data-mobile-enabled="false" data-break_parents="0" data-bg-image="https://gasnetgroup.it/wp-content/uploads/2023/08/CONSULTING-PROJECT-MANAGEMENT-slide-Gasnet-Group-1-scaled.jpg" data-bg-repeat="false" ></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-3 fusion-flex-container fusion-parallax-left nonhundred-percent-fullwidth non-hundred-percent-height-scrolling lazyload" style="--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-color:transparent;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:70px;--awb-padding-bottom:70px;--awb-background-size:cover;--awb-flex-wrap:wrap;" data-bg="https://gasnetgroup.it/wp-content/uploads/2023/08/CONSULTING-PROJECT-MANAGEMENT-slide-Gasnet-Group-1-scaled.jpg" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-4 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height fusion-column-inner-bg-wrapper" style="--awb-padding-top:40px;--awb-padding-bottom:40px;--awb-inner-bg-blend:overlay;--awb-inner-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/consulenza-project-management/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-4 fusion-sep-none fusion-title-text fusion-title-size-three" style="--awb-text-color:var(--awb-color1);--awb-margin-bottom:0px;"><h3 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;--fontSize:32;line-height:var(--awb-typography1-line-height);">CONSULENZA &amp; PROJECT MANAGEMENT<br /></h3></div></div></div></div></div><div class="fusion-bg-parallax" data-bg-align="center center" data-direction="right" data-mute="false" data-opacity="100" data-velocity="-0.7" data-mobile-enabled="false" data-break_parents="0" data-bg-image="https://gasnetgroup.it/wp-content/uploads/2023/08/SECURITY-NETWORKING-slide-Gasnet-Group-1-scaled.jpg" data-bg-repeat="false" ></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-4 fusion-flex-container fusion-parallax-right nonhundred-percent-fullwidth non-hundred-percent-height-scrolling lazyload" style="--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-color:transparent;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:70px;--awb-padding-bottom:70px;--awb-background-size:cover;--awb-flex-wrap:wrap;" data-bg="https://gasnetgroup.it/wp-content/uploads/2023/08/SECURITY-NETWORKING-slide-Gasnet-Group-1-scaled.jpg" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-5 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height fusion-column-inner-bg-wrapper" style="--awb-padding-top:40px;--awb-padding-bottom:40px;--awb-inner-bg-blend:overlay;--awb-inner-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/progettazione-sicurezza-infrastrutture-it/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-5 fusion-sep-none fusion-title-text fusion-title-size-three" style="--awb-text-color:var(--awb-color1);--awb-margin-bottom:0px;"><h3 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;--fontSize:32;line-height:var(--awb-typography1-line-height);">PROGETTAZIONE &amp; SICUREZZA INFRASTRUTTURE IT</h3></div></div></div></div></div><div class="fusion-bg-parallax" data-bg-align="center center" data-direction="left" data-mute="false" data-opacity="100" data-velocity="-0.7" data-mobile-enabled="false" data-break_parents="0" data-bg-image="https://gasnetgroup.it/wp-content/uploads/2023/08/SOFTWARE-APP-DEVELOPMENT-slide-Gasnet-Group-1-scaled.jpg" data-bg-repeat="false" ></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-5 fusion-flex-container fusion-parallax-left nonhundred-percent-fullwidth non-hundred-percent-height-scrolling lazyload" style="--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-color:transparent;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:70px;--awb-padding-bottom:70px;--awb-background-size:cover;--awb-flex-wrap:wrap;" data-bg="https://gasnetgroup.it/wp-content/uploads/2023/08/SOFTWARE-APP-DEVELOPMENT-slide-Gasnet-Group-1-scaled.jpg" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-6 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height fusion-column-inner-bg-wrapper" style="--awb-padding-top:40px;--awb-padding-bottom:40px;--awb-inner-bg-blend:overlay;--awb-inner-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/sviluppo-software-app/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-6 fusion-sep-none fusion-title-text fusion-title-size-three" style="--awb-text-color:var(--awb-color1);--awb-margin-bottom:0px;"><h3 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;--fontSize:32;line-height:var(--awb-typography1-line-height);">APPLICAZIONI SOFTWARE<br /></h3></div></div></div></div></div><div class="fusion-bg-parallax" data-bg-align="center center" data-direction="left" data-mute="false" data-opacity="100" data-velocity="-0.7" data-mobile-enabled="false" data-break_parents="0" data-bg-image="https://gasnetgroup.it/wp-content/uploads/2025/02/SOLUZIONI-AI-SU-MISURA-slide-Gasnet-Group-scaled.jpg" data-bg-repeat="false" ></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-6 fusion-flex-container fusion-parallax-left nonhundred-percent-fullwidth non-hundred-percent-height-scrolling lazyload" style="--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-color:transparent;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:70px;--awb-padding-bottom:70px;--awb-background-size:cover;--awb-flex-wrap:wrap;" data-bg="https://gasnetgroup.it/wp-content/uploads/2025/02/SOLUZIONI-AI-SU-MISURA-slide-Gasnet-Group-scaled.jpg" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-7 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height fusion-column-inner-bg-wrapper" style="--awb-padding-top:40px;--awb-padding-bottom:40px;--awb-inner-bg-blend:overlay;--awb-inner-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/intelligenza-artificiale/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-7 fusion-sep-none fusion-title-text fusion-title-size-three" style="--awb-text-color:var(--awb-color1);--awb-margin-bottom:0px;"><h3 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;--fontSize:32;line-height:var(--awb-typography1-line-height);">INTELLIGENZA ARTIFICIALE</h3></div></div></div></div></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-7 fusion-flex-container hundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-overflow:visible;--awb-margin-top:-5px;--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="width:calc( 100% + 0px ) !important;max-width:calc( 100% + 0px ) !important;margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-8 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height" style="--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-separator fusion-full-width-sep" style="align-self: flex-start;margin-right:auto;width:100%;"></div></div></div></div></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-8 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-background-position:left top;--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:42px;--awb-padding-bottom:20px;--awb-padding-top-small:50px;--awb-padding-bottom-small:0px;--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-center fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-9 fusion_builder_column_1_3 1_3 fusion-flex-column" style="--awb-bg-position:right center;--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-border-color:var(--awb-color4);--awb-border-right:3px;--awb-border-style:solid;--awb-width-large:33.333333333333%;--awb-margin-top-large:0px;--awb-spacing-right-large:3.84%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:5.76%;--awb-width-medium:100%;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-8 fusion-sep-none fusion-title-text fusion-title-size-two" style="--awb-margin-bottom:20px;--awb-margin-bottom-small:0px;--awb-margin-bottom-medium:0px;--awb-font-size:45px;"><h2 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;font-size:1em;--fontSize:45;line-height:var(--awb-typography1-line-height);"><span style="font-size: 43px;" data-fusion-font="true">LE NOSTRE <span style="font-size: 42px; color: var(--awb-color5);" data-fusion-font="true">CERTIFICAZION</span></span><span style="font-size: 42px; color: var(--awb-color5);" data-fusion-font="true">I</span></h2></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-10 fusion_builder_column_2_3 2_3 fusion-flex-column" style="--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-width-large:66.666666666667%;--awb-margin-top-large:20px;--awb-spacing-right-large:2.88%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:3.84%;--awb-width-medium:100%;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-text fusion-text-3" style="--awb-font-size:var(--awb-typography2-font-size);--awb-line-height:1.6;--awb-letter-spacing:var(--awb-typography2-letter-spacing);--awb-text-transform:var(--awb-typography2-text-transform);--awb-text-font-family:var(--awb-typography2-font-family);--awb-text-font-weight:var(--awb-typography2-font-weight);--awb-text-font-style:var(--awb-typography2-font-style);"><p>Da sempre Gas.Net Group lavora secondo elevati standard qualitativi monitorando processi e prestazioni conseguendo le Certificazioni <span style="color: var(--awb-color5);">ISO 9001</span> e <span style="color: var(--awb-color5);">ISO/IEC 27001</span></p>
</div></div></div></div></div>
<div class="fusion-fullwidth fullwidth-box fusion-builder-row-9 fusion-flex-container has-pattern-background has-mask-background nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-bottom:43px;--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-11 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="--awb-liftup-border-radius:0px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><div class="awb-image-frame awb-image-frame-2 imageframe-liftup"><span class=" fusion-imageframe imageframe-glow imageframe-2" style="-webkit-box-shadow: 0 0 4px rgba(40,40,40,0.3);box-shadow: 0 0 4px rgba(40,40,40,0.3);"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/certificazioni/" target="_self" aria-label="ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105"><img fetchpriority="high" decoding="async" width="1729" height="2445" src="https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg" alt class="lazyload img-responsive wp-image-133177" srcset="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%271729%27%20height%3D%272445%27%20viewBox%3D%270%200%201729%202445%27%3E%3Crect%20width%3D%271729%27%20height%3D%272445%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-srcset="https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-200x283.jpg 200w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-400x566.jpg 400w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-600x848.jpg 600w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-800x1131.jpg 800w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-1200x1697.jpg 1200w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg 1729w" data-sizes="auto" data-orig-sizes="(max-width: 800px) 100vw, (max-width: 640px) 100vw, 400px" /></a></span></div></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-12 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="--awb-liftup-border-radius:0px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><div class="awb-image-frame awb-image-frame-3 imageframe-liftup"><span class=" fusion-imageframe imageframe-glow imageframe-3" style="-webkit-box-shadow: 0 0 4px rgba(40,40,40,0.3);box-shadow: 0 0 4px rgba(40,40,40,0.3);"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/certificazioni/" target="_self" aria-label="ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105"><img decoding="async" width="1729" height="2445" src="https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg" alt class="lazyload img-responsive wp-image-133176" srcset="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%271729%27%20height%3D%272445%27%20viewBox%3D%270%200%201729%202445%27%3E%3Crect%20width%3D%271729%27%20height%3D%272445%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-srcset="https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-200x283.jpg 200w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-400x566.jpg 400w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-600x848.jpg 600w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-800x1131.jpg 800w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-1200x1697.jpg 1200w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg 1729w" data-sizes="auto" data-orig-sizes="(max-width: 800px) 100vw, (max-width: 640px) 100vw, 400px" /></a></span></div></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-13 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="--awb-liftup-border-radius:0px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><div class="awb-image-frame awb-image-frame-4 imageframe-liftup"><span class=" fusion-imageframe imageframe-glow imageframe-4" style="-webkit-box-shadow: 0 0 4px rgba(40,40,40,0.3);box-shadow: 0 0 4px rgba(40,40,40,0.3);"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/certificazioni/" target="_self" aria-label="IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654"><img decoding="async" width="1729" height="2445" src="https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654.jpg" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654.jpg" alt class="lazyload img-responsive wp-image-1001" srcset="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%271729%27%20height%3D%272445%27%20viewBox%3D%270%200%201729%202445%27%3E%3Crect%20width%3D%271729%27%20height%3D%272445%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-srcset="https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-200x283.jpg 200w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-400x566.jpg 400w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-600x848.jpg 600w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-800x1131.jpg 800w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-1200x1697.jpg 1200w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654.jpg 1729w" data-sizes="auto" data-orig-sizes="(max-width: 800px) 100vw, (max-width: 640px) 100vw, 400px" /></a></span></div></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-14 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="--awb-liftup-border-radius:0px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><div class="awb-image-frame awb-image-frame-5 imageframe-liftup"><span class=" fusion-imageframe imageframe-glow imageframe-5" style="-webkit-box-shadow: 0 0 4px rgba(40,40,40,0.3);box-shadow: 0 0 4px rgba(40,40,40,0.3);"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/certificazioni/" target="_self" aria-label="ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744"><img decoding="async" width="1729" height="2445" src="https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744.jpg" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744.jpg" alt class="lazyload img-responsive wp-image-1000" srcset="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%271729%27%20height%3D%272445%27%20viewBox%3D%270%200%201729%202445%27%3E%3Crect%20width%3D%271729%27%20height%3D%272445%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-srcset="https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-200x283.jpg 200w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-400x566.jpg 400w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-600x848.jpg 600w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-800x1131.jpg 800w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-1200x1697.jpg 1200w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744.jpg 1729w" data-sizes="auto" data-orig-sizes="(max-width: 800px) 100vw, (max-width: 640px) 100vw, 400px" /></a></span></div></div></div></div></div></div>
							</div>
												</div>
	</section>
						
					</div>  <!-- fusion-row -->
				</main>  <!-- #main -->
				
				
								
					<div class="fusion-tb-footer fusion-footer"><div class="fusion-footer-widget-area fusion-widget-area"><div class="fusion-fullwidth fullwidth-box fusion-builder-row-10 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:20px;--awb-padding-bottom:20px;--awb-padding-top-small:20px;--awb-padding-bottom-small:20px;--awb-background-color:var(--awb-color8);--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-justify-content-center fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-15 fusion_builder_column_1_3 1_3 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:33.333333333333%;--awb-margin-top-large:0px;--awb-spacing-right-large:5.76%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:5.76%;--awb-width-medium:50%;--awb-order-medium:0;--awb-spacing-right-medium:3.84%;--awb-spacing-left-medium:3.84%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-margin-bottom-small:30px;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-social-links fusion-social-links-1" style="--awb-margin-top:0px;--awb-margin-right:0px;--awb-margin-bottom:0px;--awb-margin-left:0px;--awb-margin-top-small:20px;--awb-box-border-top:0px;--awb-box-border-right:0px;--awb-box-border-bottom:0px;--awb-box-border-left:0px;--awb-icon-colors-hover:var(--awb-color5);--awb-box-colors-hover:var(--awb-color7);--awb-box-border-color:var(--awb-color3);--awb-box-border-color-hover:var(--awb-color4);--awb-alignment-small:center;"><div class="fusion-social-networks boxed-icons color-type-custom"><div class="fusion-social-networks-wrapper"><a class="fusion-social-network-icon fusion-tooltip fusion-facebook awb-icon-facebook" style="color:var(--awb-color4);font-size:21px;width:21px;background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-radius:99px;" data-placement="top" data-title="Facebook" data-toggle="tooltip" title="Facebook" aria-label="facebook" target="_blank" rel="noopener noreferrer" href="http://www.facebook.com/GasNetGroup"></a><a class="fusion-social-network-icon fusion-tooltip fusion-instagram awb-icon-instagram" style="color:var(--awb-color4);font-size:21px;width:21px;background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-radius:99px;" data-placement="top" data-title="Instagram" data-toggle="tooltip" title="Instagram" aria-label="instagram" target="_blank" rel="noopener noreferrer" href="https://www.instagram.com/gasnetgroup"></a><a class="fusion-social-network-icon fusion-tooltip fusion-youtube awb-icon-youtube" style="color:var(--awb-color4);font-size:21px;width:21px;background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-radius:99px;" data-placement="top" data-title="YouTube" data-toggle="tooltip" title="YouTube" aria-label="youtube" target="_blank" rel="noopener noreferrer" href="http://www.youtube.com/user/GasNetGroup"></a><a class="fusion-social-network-icon fusion-tooltip fusion-linkedin awb-icon-linkedin" style="color:var(--awb-color4);font-size:21px;width:21px;background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-radius:99px;" data-placement="top" data-title="LinkedIn" data-toggle="tooltip" title="LinkedIn" aria-label="linkedin" target="_blank" rel="noopener noreferrer" href="https://www.linkedin.com/company/gas-net-group-srl"></a></div></div></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-16 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="sm-text-align-center"><a class="fusion-button button-flat fusion-button-default-size button-custom fusion-button-default button-1 fusion-button-default-span fusion-button-default-type" style="--button_accent_color:#ffffff;--button_border_color:rgba(255,255,255,0);--button_accent_hover_color:var(--awb-color6);--button_border_hover_color:var(--awb-color6);--button_gradient_top_color:rgba(255,255,255,0);--button_gradient_bottom_color:rgba(255,255,255,0);--button_gradient_top_color_hover:hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 96.5% ));--button_gradient_bottom_color_hover:hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 96.5% ));" target="_self"  049 0 title=" 049 5384759 " aria-label=" 049 5384759 " href="tel:+390495384759"><i class="fa-phone fas awb-button__icon awb-button__icon--default button-icon-left" aria-hidden="true"></i><span class="fusion-button-text awb-button__text awb-button__text--default"> 049 5384759 </span></a></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-17 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="sm-text-align-center"><a class="fusion-button button-flat fusion-button-default-size button-custom fusion-button-default button-2 fusion-button-default-span fusion-button-default-type" style="--button_accent_color:#ffffff;--button_border_color:rgba(255,255,255,0);--button_accent_hover_color:var(--awb-color6);--button_border_hover_color:var(--awb-color6);--button_gradient_top_color:rgba(255,255,255,0);--button_gradient_bottom_color:rgba(255,255,255,0);--button_gradient_top_color_hover:hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 96.5% ));--button_gradient_bottom_color_hover:hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 96.5% ));" target="_self" EMAIL US title="EMAIL US" aria-label="EMAIL US" href="mailto:commerciale@gasnetgroup.com"><i class="fa-envelope fas awb-button__icon awb-button__icon--default button-icon-left" aria-hidden="true"></i><span class="fusion-button-text awb-button__text awb-button__text--default">EMAIL US</span></a></div></div></div></div></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-11 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--link_color: hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 24% ));--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:15px;--awb-padding-bottom:15px;--awb-background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 5%),var(--awb-color8-a));--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-center fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-18 fusion_builder_column_1_1 1_1 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:1.92%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:1.92%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="text-align:center;--awb-margin-top:5px;--awb-margin-bottom:5px;--awb-max-width:150px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><span class=" fusion-imageframe imageframe-none imageframe-6 hover-type-none"><img decoding="async" width="100" height="45" alt="GasNet Group" title="Gas.Net Group" src="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27100%27%20height%3D%2745%27%20viewBox%3D%270%200%20100%2045%27%3E%3Crect%20width%3D%27100%27%20height%3D%2745%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2023/08/logo-gasnet.group_bianco_45px.png" class="lazyload img-responsive wp-image-820"/></span></div><div class="fusion-text fusion-text-4 fusion-text-no-margin" style="--awb-font-size:12px;--awb-text-color:#787878;"><p style="text-align: center;">Gas.Net Group srl &#8211; Via Roma, 1 35020 Tribano (PD)<br />
Tel. 049 5384759 &#8211; P.Iva e Cod. Fiscale: 03306860283</p>
</div><div class="fusion-text fusion-text-5 md-text-align-center sm-text-align-center" style="--awb-font-size:12px;--awb-line-height:0;--awb-text-color:hsla(var(--awb-color7-h),var(--awb-color7-s),calc( var(--awb-color7-l) + 27% ),var(--awb-color7-a));"><p style="text-align: center;"><a href="https://gasnetgroup.it/certificazioni/">Azienda Certificata ISO 9001 e ISO/IEC 27001</a></p>
</div><div class="fusion-text fusion-text-6" style="--awb-font-size:12px;"><p style="text-align: center;"><a href="https://gasnetgroup.it/newsletter/"><b>ISCRIVITI ALLA NEWSLETTER</b></a><br />
@ Gas.Net Group <span class="awb-dd awb-dd-1"><span class="awb-dd-params">2026</span></span>. Tutti i diritti riservati.<br />
<a href="https://gasnetgroup.it/privacy-policy/">Privacy Policy</a> | <a href="https://gasnetgroup.it/cookie-policy/">Cookie Policy</a></p>
</div></div></div></div></div>
</div></div>
																</div> <!-- wrapper -->
		</div> <!-- #boxed-wrapper -->
				<a class="fusion-one-page-text-link fusion-page-load-link" tabindex="-1" href="#" aria-hidden="true">Page load link</a>

		<div class="avada-footer-scripts">
			<script type="text/javascript">var fusionNavIsCollapsed=function(e){var t,n;window.innerWidth<=e.getAttribute("data-breakpoint")?(e.classList.add("collapse-enabled"),e.classList.remove("awb-menu_desktop"),e.classList.contains("expanded")||window.dispatchEvent(new CustomEvent("fusion-mobile-menu-collapsed",{detail:{nav:e}})),(n=e.querySelectorAll(".menu-item-has-children.expanded")).length&&n.forEach(function(e){e.querySelector(".awb-menu__open-nav-submenu_mobile").setAttribute("aria-expanded","false")})):(null!==e.querySelector(".menu-item-has-children.expanded .awb-menu__open-nav-submenu_click")&&e.querySelector(".menu-item-has-children.expanded .awb-menu__open-nav-submenu_click").click(),e.classList.remove("collapse-enabled"),e.classList.add("awb-menu_desktop"),null!==e.querySelector(".awb-menu__main-ul")&&e.querySelector(".awb-menu__main-ul").removeAttribute("style")),e.classList.add("no-wrapper-transition"),clearTimeout(t),t=setTimeout(()=>{e.classList.remove("no-wrapper-transition")},400),e.classList.remove("loading")},fusionRunNavIsCollapsed=function(){var e,t=document.querySelectorAll(".awb-menu");for(e=0;e<t.length;e++)fusionNavIsCollapsed(t[e])};function avadaGetScrollBarWidth(){var e,t,n,l=document.createElement("p");return l.style.width="100%",l.style.height="200px",(e=document.createElement("div")).style.position="absolute",e.style.top="0px",e.style.left="0px",e.style.visibility="hidden",e.style.width="200px",e.style.height="150px",e.style.overflow="hidden",e.appendChild(l),document.body.appendChild(e),t=l.offsetWidth,e.style.overflow="scroll",t==(n=l.offsetWidth)&&(n=e.clientWidth),document.body.removeChild(e),jQuery("html").hasClass("awb-scroll")&&10<t-n?10:t-n}fusionRunNavIsCollapsed(),window.addEventListener("fusion-resize-horizontal",fusionRunNavIsCollapsed);</script><script type="speculationrules">
{"prefetch":[{"source":"document","where":{"and":[{"href_matches":"/*"},{"not":{"href_matches":["/wp-*.php","/wp-admin/*","/wp-content/uploads/*","/wp-content/*","/wp-content/plugins/*","/wp-content/themes/Avada/*","/*\\?(.+)"]}},{"not":{"selector_matches":"a[rel~=\"nofollow\"]"}},{"not":{"selector_matches":".no-prefetch, .no-prefetch a"}}]},"eagerness":"conservative"}]}
</script>

            <script type="text/javascript">
            document.addEventListener("DOMContentLoaded", function () {
                setTimeout(function () {
                    var s = document.createElement("script");
                    s.src = "https://cdn.jotfor.ms/agent/embedjs/0196cf368923737cba8ea4f8e67833e1f584/embed.js?skipWelcome=1&#038;maximizable=1";
                    s.defer = true;
                    document.head.appendChild(s);
                }, 2000);
            });
            </script>
        <script type="text/javascript" src="https://gasnetgroup.it/wp-includes/js/jquery/jquery.min.js?ver=3.7.1" id="jquery-core-js"></script>
<script type="text/javascript" id="dlm-xhr-js-extra">
/* <![CDATA[ */
var dlmXHRtranslations = {"error":"An error occurred while trying to download the file. Please try again.","not_found":"Il download non esiste","no_file_path":"No file path defined.","no_file_paths":"Nessun percorso definito.","filetype":"Download is not allowed for this file type.","file_access_denied":"Access denied to this file.","access_denied":"Access denied. You do not have permission to download this file.","security_error":"Something is wrong with the file path.","file_not_found":"File non trovato."};
//# sourceURL=dlm-xhr-js-extra
/* ]]> */
</script>
<script type="text/javascript" id="dlm-xhr-js-before">
/* <![CDATA[ */
const dlmXHR = {"xhr_links":{"class":["download-link","download-button"]},"prevent_duplicates":true,"ajaxUrl":"https:\/\/gasnetgroup.it\/wp-admin\/admin-ajax.php"}; dlmXHRinstance = {}; const dlmXHRGlobalLinks = "https://gasnetgroup.it/download/"; const dlmNonXHRGlobalLinks = []; dlmXHRgif = "https://gasnetgroup.it/wp-includes/images/spinner.gif"; const dlmXHRProgress = "1"
//# sourceURL=dlm-xhr-js-before
/* ]]> */
</script>
<script type="text/javascript" src="https://gasnetgroup.it/wp-content/plugins/download-monitor/assets/js/dlm-xhr.min.js?ver=5.1.7" id="dlm-xhr-js"></script>
<script type="text/javascript" src="https://gasnetgroup.it/wp-content/uploads/fusion-scripts/d66a74ce6d808b403b6eea9d9828ef39.min.js?ver=3.14.2" id="fusion-scripts-js"></script>
				<script type="text/javascript">
				jQuery( document ).ready( function() {
					var ajaxurl = 'https://gasnetgroup.it/wp-admin/admin-ajax.php';
					if ( 0 < jQuery( '.fusion-login-nonce' ).length ) {
						jQuery.get( ajaxurl, { 'action': 'fusion_login_nonce' }, function( response ) {
							jQuery( '.fusion-login-nonce' ).html( response );
						});
					}
				});
				</script>
						</div>

			<section class="to-top-container to-top-right" aria-labelledby="awb-to-top-label">
		<a href="#" id="toTop" class="fusion-top-top-link">
			<span id="awb-to-top-label" class="screen-reader-text">Torna in cima</span>

					</a>
	</section>
		</body>
</html>

LOGO;ENCODING=b;TYPE=:<!DOCTYPE html>
<html class="avada-html-layout-wide avada-html-header-position-top avada-is-100-percent-template" dir="ltr" lang="it-IT" prefix="og: https://ogp.me/ns#" prefix="og: http://ogp.me/ns# fb: http://ogp.me/ns/fb#">
<head>
	<meta http-equiv="X-UA-Compatible" content="IE=edge" />
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
	<meta name="viewport" content="width=device-width, initial-scale=1" />
	<script type="text/javascript" data-cookieconsent="ignore">
	window.dataLayer = window.dataLayer || [];

	function gtag() {
		dataLayer.push(arguments);
	}

	gtag("consent", "default", {
		ad_personalization: "denied",
		ad_storage: "denied",
		ad_user_data: "denied",
		analytics_storage: "denied",
		functionality_storage: "denied",
		personalization_storage: "denied",
		security_storage: "granted",
		wait_for_update: 500,
	});
	gtag("set", "ads_data_redaction", true);
	gtag("set", "url_passthrough", true);
</script>
<script type="text/javascript"
		id="Cookiebot"
		src="https://consent.cookiebot.com/uc.js"
		data-implementation="wp"
		data-cbid="c263e444-8f5e-4fcc-8d67-aefd900a374b"
							data-blockingmode="auto"
	></script>
<title>GasNet Group - Soluzioni innovative per le tue esigenze</title>

		<!-- All in One SEO 4.9.3 - aioseo.com -->
	<meta name="description" content="Da oltre 20 anni, Gas.Net Group Srl è un punto di riferimento nel mondo del software, della sicurezza informatica e della consulenza IT." />
	<meta name="robots" content="max-image-preview:large" />
	<link rel="canonical" href="https://gasnetgroup.it/" />
	<meta name="generator" content="All in One SEO (AIOSEO) 4.9.3" />
		<meta property="og:locale" content="it_IT" />
		<meta property="og:site_name" content="GasNet Group -" />
		<meta property="og:type" content="website" />
		<meta property="og:title" content="GasNet Group - Soluzioni innovative per le tue esigenze" />
		<meta property="og:description" content="Da oltre 20 anni, Gas.Net Group Srl è un punto di riferimento nel mondo del software, della sicurezza informatica e della consulenza IT." />
		<meta property="og:url" content="https://gasnetgroup.it/" />
		<meta name="twitter:card" content="summary_large_image" />
		<meta name="twitter:title" content="GasNet Group - Soluzioni innovative per le tue esigenze" />
		<meta name="twitter:description" content="Da oltre 20 anni, Gas.Net Group Srl è un punto di riferimento nel mondo del software, della sicurezza informatica e della consulenza IT." />
		<script type="application/ld+json" class="aioseo-schema">
			{"@context":"https:\/\/schema.org","@graph":[{"@type":"BreadcrumbList","@id":"https:\/\/gasnetgroup.it\/#breadcrumblist","itemListElement":[{"@type":"ListItem","@id":"https:\/\/gasnetgroup.it#listItem","position":1,"name":"Home"}]},{"@type":"Organization","@id":"https:\/\/gasnetgroup.it\/#organization","name":"GasNet Group","url":"https:\/\/gasnetgroup.it\/"},{"@type":"WebPage","@id":"https:\/\/gasnetgroup.it\/#webpage","url":"https:\/\/gasnetgroup.it\/","name":"GasNet Group - Soluzioni innovative per le tue esigenze","description":"Da oltre 20 anni, Gas.Net Group Srl \u00e8 un punto di riferimento nel mondo del software, della sicurezza informatica e della consulenza IT.","inLanguage":"it-IT","isPartOf":{"@id":"https:\/\/gasnetgroup.it\/#website"},"breadcrumb":{"@id":"https:\/\/gasnetgroup.it\/#breadcrumblist"},"datePublished":"2021-05-12T15:41:37+00:00","dateModified":"2025-03-25T16:03:33+00:00"},{"@type":"WebSite","@id":"https:\/\/gasnetgroup.it\/#website","url":"https:\/\/gasnetgroup.it\/","name":"GasNet Group","inLanguage":"it-IT","publisher":{"@id":"https:\/\/gasnetgroup.it\/#organization"}}]}
		</script>
		<!-- All in One SEO -->

<meta name="dlm-version" content="5.1.7">    <script>
    window.addEventListener('CookiebotOnLoad', function (e) {
        if (typeof Cookiebot !== 'undefined') {
            
            // Block HeyGen Marketing cookies
            if (!Cookiebot.consent.marketing) {
                // Block HeyGen marketing cookies
                document.cookie = 'pacific/MOVIO_SESSION_ID=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.heygen.com';
                document.cookie = 'pacific/SID=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.heygen.com';
                document.cookie = 'x-movio-v-id=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.heygen.com';
                document.cookie = 'x-movio-v-id=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.app.heygen.com';
                
                // Block Jotform marketing cookies
                document.cookie = 'userReferer=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.jotform.com';
            }
            
            // Block HeyGen Statistics cookies
            if (!Cookiebot.consent.statistics) {
                // Block HeyGen PostHog cookies
                document.cookie = 'ph_#_posthog=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.heygen.com';
                document.cookie = 'ph_#_posthog=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.app.heygen.com';
                document.cookie = 'ph_#_primary_window_exists=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.app.heygen.com';
                
                // Block Jotform statistics cookies
                document.cookie = 'guest=; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/; domain=.jotform.com';
            }
        }
    });
    </script>
    <link rel='dns-prefetch' href='//www.googletagmanager.com' />
<link rel='dns-prefetch' href='//use.fontawesome.com' />
<link rel="alternate" type="application/rss+xml" title="GasNet Group &raquo; Feed" href="https://gasnetgroup.it/feed/" />
<link rel="alternate" type="application/rss+xml" title="GasNet Group &raquo; Feed dei commenti" href="https://gasnetgroup.it/comments/feed/" />
								<link rel="icon" href="https://gasnetgroup.it/wp-content/uploads/2023/09/favicon-gasnet-64px.png" type="image/png" />
		
					<!-- Apple Touch Icon -->
						<link rel="apple-touch-icon" sizes="180x180" href="https://gasnetgroup.it/wp-content/uploads/2023/09/favicon-gasnet-180px.png" type="image/png">
		
					<!-- Android Icon -->
						<link rel="icon" sizes="192x192" href="https://gasnetgroup.it/wp-content/uploads/2023/09/favicon-gasnet-192px.png" type="image/png">
		
					<!-- MS Edge Icon -->
						<meta name="msapplication-TileImage" content="https://gasnetgroup.it/wp-content/uploads/2023/09/favicon-gasnet-270px.png" type="image/png">
				<link rel="alternate" title="oEmbed (JSON)" type="application/json+oembed" href="https://gasnetgroup.it/wp-json/oembed/1.0/embed?url=https%3A%2F%2Fgasnetgroup.it%2F" />
<link rel="alternate" title="oEmbed (XML)" type="text/xml+oembed" href="https://gasnetgroup.it/wp-json/oembed/1.0/embed?url=https%3A%2F%2Fgasnetgroup.it%2F&#038;format=xml" />
<style id='wp-img-auto-sizes-contain-inline-css' type='text/css'>
img:is([sizes=auto i],[sizes^="auto," i]){contain-intrinsic-size:3000px 1500px}
/*# sourceURL=wp-img-auto-sizes-contain-inline-css */
</style>
<style id='font-awesome-svg-styles-default-inline-css' type='text/css'>
.svg-inline--fa {
  display: inline-block;
  height: 1em;
  overflow: visible;
  vertical-align: -.125em;
}
/*# sourceURL=font-awesome-svg-styles-default-inline-css */
</style>
<link rel='stylesheet' id='font-awesome-svg-styles-css' href='https://gasnetgroup.it/wp-content/uploads/font-awesome/v6.7.2/css/svg-with-js.css' type='text/css' media='all' />
<style id='font-awesome-svg-styles-inline-css' type='text/css'>
   .wp-block-font-awesome-icon svg::before,
   .wp-rich-text-font-awesome-icon svg::before {content: unset;}
/*# sourceURL=font-awesome-svg-styles-inline-css */
</style>
<style id='global-styles-inline-css' type='text/css'>
:root{--wp--preset--aspect-ratio--square: 1;--wp--preset--aspect-ratio--4-3: 4/3;--wp--preset--aspect-ratio--3-4: 3/4;--wp--preset--aspect-ratio--3-2: 3/2;--wp--preset--aspect-ratio--2-3: 2/3;--wp--preset--aspect-ratio--16-9: 16/9;--wp--preset--aspect-ratio--9-16: 9/16;--wp--preset--color--black: #000000;--wp--preset--color--cyan-bluish-gray: #abb8c3;--wp--preset--color--white: #ffffff;--wp--preset--color--pale-pink: #f78da7;--wp--preset--color--vivid-red: #cf2e2e;--wp--preset--color--luminous-vivid-orange: #ff6900;--wp--preset--color--luminous-vivid-amber: #fcb900;--wp--preset--color--light-green-cyan: #7bdcb5;--wp--preset--color--vivid-green-cyan: #00d084;--wp--preset--color--pale-cyan-blue: #8ed1fc;--wp--preset--color--vivid-cyan-blue: #0693e3;--wp--preset--color--vivid-purple: #9b51e0;--wp--preset--color--awb-color-1: #ffffff;--wp--preset--color--awb-color-2: #f8f8f8;--wp--preset--color--awb-color-3: #e2e3e8;--wp--preset--color--awb-color-4: #e0dede;--wp--preset--color--awb-color-5: #0877a5;--wp--preset--color--awb-color-6: #5a5d62;--wp--preset--color--awb-color-7: #333333;--wp--preset--color--awb-color-8: #24272d;--wp--preset--color--awb-color-custom-1: #84d4e8;--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple: linear-gradient(135deg,rgb(6,147,227) 0%,rgb(155,81,224) 100%);--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan: linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%);--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange: linear-gradient(135deg,rgb(252,185,0) 0%,rgb(255,105,0) 100%);--wp--preset--gradient--luminous-vivid-orange-to-vivid-red: linear-gradient(135deg,rgb(255,105,0) 0%,rgb(207,46,46) 100%);--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray: linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%);--wp--preset--gradient--cool-to-warm-spectrum: linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%);--wp--preset--gradient--blush-light-purple: linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%);--wp--preset--gradient--blush-bordeaux: linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%);--wp--preset--gradient--luminous-dusk: linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%);--wp--preset--gradient--pale-ocean: linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%);--wp--preset--gradient--electric-grass: linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%);--wp--preset--gradient--midnight: linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%);--wp--preset--font-size--small: 11.25px;--wp--preset--font-size--medium: 20px;--wp--preset--font-size--large: 22.5px;--wp--preset--font-size--x-large: 42px;--wp--preset--font-size--normal: 15px;--wp--preset--font-size--xlarge: 30px;--wp--preset--font-size--huge: 45px;--wp--preset--spacing--20: 0.44rem;--wp--preset--spacing--30: 0.67rem;--wp--preset--spacing--40: 1rem;--wp--preset--spacing--50: 1.5rem;--wp--preset--spacing--60: 2.25rem;--wp--preset--spacing--70: 3.38rem;--wp--preset--spacing--80: 5.06rem;--wp--preset--shadow--natural: 6px 6px 9px rgba(0, 0, 0, 0.2);--wp--preset--shadow--deep: 12px 12px 50px rgba(0, 0, 0, 0.4);--wp--preset--shadow--sharp: 6px 6px 0px rgba(0, 0, 0, 0.2);--wp--preset--shadow--outlined: 6px 6px 0px -3px rgb(255, 255, 255), 6px 6px rgb(0, 0, 0);--wp--preset--shadow--crisp: 6px 6px 0px rgb(0, 0, 0);}:where(.is-layout-flex){gap: 0.5em;}:where(.is-layout-grid){gap: 0.5em;}body .is-layout-flex{display: flex;}.is-layout-flex{flex-wrap: wrap;align-items: center;}.is-layout-flex > :is(*, div){margin: 0;}body .is-layout-grid{display: grid;}.is-layout-grid > :is(*, div){margin: 0;}:where(.wp-block-columns.is-layout-flex){gap: 2em;}:where(.wp-block-columns.is-layout-grid){gap: 2em;}:where(.wp-block-post-template.is-layout-flex){gap: 1.25em;}:where(.wp-block-post-template.is-layout-grid){gap: 1.25em;}.has-black-color{color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-color{color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-color{color: var(--wp--preset--color--white) !important;}.has-pale-pink-color{color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-color{color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-color{color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-color{color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-color{color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-color{color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-color{color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-color{color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-color{color: var(--wp--preset--color--vivid-purple) !important;}.has-black-background-color{background-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-background-color{background-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-background-color{background-color: var(--wp--preset--color--white) !important;}.has-pale-pink-background-color{background-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-background-color{background-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-background-color{background-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-background-color{background-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-background-color{background-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-background-color{background-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-background-color{background-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-background-color{background-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-background-color{background-color: var(--wp--preset--color--vivid-purple) !important;}.has-black-border-color{border-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-border-color{border-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-border-color{border-color: var(--wp--preset--color--white) !important;}.has-pale-pink-border-color{border-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-border-color{border-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-border-color{border-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-border-color{border-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-border-color{border-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-border-color{border-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-border-color{border-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-border-color{border-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-border-color{border-color: var(--wp--preset--color--vivid-purple) !important;}.has-vivid-cyan-blue-to-vivid-purple-gradient-background{background: var(--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple) !important;}.has-light-green-cyan-to-vivid-green-cyan-gradient-background{background: var(--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan) !important;}.has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange) !important;}.has-luminous-vivid-orange-to-vivid-red-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-orange-to-vivid-red) !important;}.has-very-light-gray-to-cyan-bluish-gray-gradient-background{background: var(--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray) !important;}.has-cool-to-warm-spectrum-gradient-background{background: var(--wp--preset--gradient--cool-to-warm-spectrum) !important;}.has-blush-light-purple-gradient-background{background: var(--wp--preset--gradient--blush-light-purple) !important;}.has-blush-bordeaux-gradient-background{background: var(--wp--preset--gradient--blush-bordeaux) !important;}.has-luminous-dusk-gradient-background{background: var(--wp--preset--gradient--luminous-dusk) !important;}.has-pale-ocean-gradient-background{background: var(--wp--preset--gradient--pale-ocean) !important;}.has-electric-grass-gradient-background{background: var(--wp--preset--gradient--electric-grass) !important;}.has-midnight-gradient-background{background: var(--wp--preset--gradient--midnight) !important;}.has-small-font-size{font-size: var(--wp--preset--font-size--small) !important;}.has-medium-font-size{font-size: var(--wp--preset--font-size--medium) !important;}.has-large-font-size{font-size: var(--wp--preset--font-size--large) !important;}.has-x-large-font-size{font-size: var(--wp--preset--font-size--x-large) !important;}
/*# sourceURL=global-styles-inline-css */
</style>

<link rel='stylesheet' id='dashicons-css' href='https://gasnetgroup.it/wp-includes/css/dashicons.min.css?ver=43bf7ecd6e2853cf806e9aee417668a4' type='text/css' media='all' />
<link rel='stylesheet' id='admin-bar-css' href='https://gasnetgroup.it/wp-includes/css/admin-bar.min.css?ver=43bf7ecd6e2853cf806e9aee417668a4' type='text/css' media='all' />
<style id='admin-bar-inline-css' type='text/css'>

    /* Hide CanvasJS credits for P404 charts specifically */
    #p404RedirectChart .canvasjs-chart-credit {
        display: none !important;
    }
    
    #p404RedirectChart canvas {
        border-radius: 6px;
    }

    .p404-redirect-adminbar-weekly-title {
        font-weight: bold;
        font-size: 14px;
        color: #fff;
        margin-bottom: 6px;
    }

    #wpadminbar #wp-admin-bar-p404_free_top_button .ab-icon:before {
        content: "\f103";
        color: #dc3545;
        top: 3px;
    }
    
    #wp-admin-bar-p404_free_top_button .ab-item {
        min-width: 80px !important;
        padding: 0px !important;
    }
    
    /* Ensure proper positioning and z-index for P404 dropdown */
    .p404-redirect-adminbar-dropdown-wrap { 
        min-width: 0; 
        padding: 0;
        position: static !important;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button_dropdown {
        position: static !important;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button_dropdown .ab-item {
        padding: 0 !important;
        margin: 0 !important;
    }
    
    .p404-redirect-dropdown-container {
        min-width: 340px;
        padding: 18px 18px 12px 18px;
        background: #23282d !important;
        color: #fff;
        border-radius: 12px;
        box-shadow: 0 8px 32px rgba(0,0,0,0.25);
        margin-top: 10px;
        position: relative !important;
        z-index: 999999 !important;
        display: block !important;
        border: 1px solid #444;
    }
    
    /* Ensure P404 dropdown appears on hover */
    #wpadminbar #wp-admin-bar-p404_free_top_button .p404-redirect-dropdown-container { 
        display: none !important;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button:hover .p404-redirect-dropdown-container { 
        display: block !important;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button:hover #wp-admin-bar-p404_free_top_button_dropdown .p404-redirect-dropdown-container {
        display: block !important;
    }
    
    .p404-redirect-card {
        background: #2c3338;
        border-radius: 8px;
        padding: 18px 18px 12px 18px;
        box-shadow: 0 2px 8px rgba(0,0,0,0.07);
        display: flex;
        flex-direction: column;
        align-items: flex-start;
        border: 1px solid #444;
    }
    
    .p404-redirect-btn {
        display: inline-block;
        background: #dc3545;
        color: #fff !important;
        font-weight: bold;
        padding: 5px 22px;
        border-radius: 8px;
        text-decoration: none;
        font-size: 17px;
        transition: background 0.2s, box-shadow 0.2s;
        margin-top: 8px;
        box-shadow: 0 2px 8px rgba(220,53,69,0.15);
        text-align: center;
        line-height: 1.6;
    }
    
    .p404-redirect-btn:hover {
        background: #c82333;
        color: #fff !important;
        box-shadow: 0 4px 16px rgba(220,53,69,0.25);
    }
    
    /* Prevent conflicts with other admin bar dropdowns */
    #wpadminbar .ab-top-menu > li:hover > .ab-item,
    #wpadminbar .ab-top-menu > li.hover > .ab-item {
        z-index: auto;
    }
    
    #wpadminbar #wp-admin-bar-p404_free_top_button:hover > .ab-item {
        z-index: 999998 !important;
    }
    
/*# sourceURL=admin-bar-inline-css */
</style>
<link rel='stylesheet' id='font-awesome-official-css' href='https://use.fontawesome.com/releases/v6.7.2/css/all.css' type='text/css' media='all' integrity="sha384-nRgPTkuX86pH8yjPJUAFuASXQSSl2/bBUiNV47vSYpKFxHJhbcrGnmlYpYJMeD7a" crossorigin="anonymous" />
<link rel='stylesheet' id='fusion-dynamic-css-css' href='https://gasnetgroup.it/wp-content/uploads/fusion-styles/b166e2c72e3ed1a8f964518cae9e9de8.min.css?ver=3.14.2' type='text/css' media='all' />
<link rel='stylesheet' id='font-awesome-official-v4shim-css' href='https://use.fontawesome.com/releases/v6.7.2/css/v4-shims.css' type='text/css' media='all' integrity="sha384-npPMK6zwqNmU3qyCCxEcWJkLBNYxEFM1nGgSoAWuCCXqVVz0cvwKEMfyTNkOxM2N" crossorigin="anonymous" />

<!-- Snippet del tag Google (gtag.js) aggiunto da Site Kit -->
<!-- Snippet Google Analytics aggiunto da Site Kit -->
<script type="text/javascript" src="https://www.googletagmanager.com/gtag/js?id=GT-NS9ZXDQ" id="google_gtagjs-js" async></script>
<script type="text/javascript" id="google_gtagjs-js-after">
/* <![CDATA[ */
window.dataLayer = window.dataLayer || [];function gtag(){dataLayer.push(arguments);}
gtag("set","linker",{"domains":["gasnetgroup.it"]});
gtag("js", new Date());
gtag("set", "developer_id.dZTNiMT", true);
gtag("config", "GT-NS9ZXDQ");
//# sourceURL=google_gtagjs-js-after
/* ]]> */
</script>
<link rel="https://api.w.org/" href="https://gasnetgroup.it/wp-json/" /><link rel="alternate" title="JSON" type="application/json" href="https://gasnetgroup.it/wp-json/wp/v2/pages/750" /><link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://gasnetgroup.it/xmlrpc.php?rsd" />

<link rel='shortlink' href='https://gasnetgroup.it/' />
<meta name="generator" content="Site Kit by Google 1.172.0" /><!-- HFCM by 99 Robots - Snippet # 2: googleConsentMode di Cookiebot -->
<script>
  // Imposta l'impostazione `googleConsentMode` di Cookiebot su `true`
  window.cookieconsent.options.googleConsentMode = true;

  // Controlla se lo script di reCaptcha imposta cookie che non sono necessari per il funzionamento del servizio
  if (document.querySelector('script[src="https://www.google.com/recaptcha/api.js"]') !== null) {
    // Assegna l'attributo `data-cookieconsent` al tag di script
    document.querySelector('script[src="https://www.google.com/recaptcha/api.js"]').setAttribute('data-cookieconsent', 'preferences,statistics,marketing');
  }
</script>
<!-- /end HFCM by 99 Robots -->
<!-- HFCM by 99 Robots - Snippet # 3: Verifica proprietà Google Search Console -->
<meta name="google-site-verification" content="1ORhh8FekbJ5zWZe8kzoTJTa6CAahFRstHwUQJxJMMs" />
<!-- /end HFCM by 99 Robots -->
<style type="text/css" id="css-fb-visibility">@media screen and (max-width: 640px){.fusion-no-small-visibility{display:none !important;}body .sm-text-align-center{text-align:center !important;}body .sm-text-align-left{text-align:left !important;}body .sm-text-align-right{text-align:right !important;}body .sm-text-align-justify{text-align:justify !important;}body .sm-flex-align-center{justify-content:center !important;}body .sm-flex-align-flex-start{justify-content:flex-start !important;}body .sm-flex-align-flex-end{justify-content:flex-end !important;}body .sm-mx-auto{margin-left:auto !important;margin-right:auto !important;}body .sm-ml-auto{margin-left:auto !important;}body .sm-mr-auto{margin-right:auto !important;}body .fusion-absolute-position-small{position:absolute;width:100%;}.awb-sticky.awb-sticky-small{ position: sticky; top: var(--awb-sticky-offset,0); }}@media screen and (min-width: 641px) and (max-width: 800px){.fusion-no-medium-visibility{display:none !important;}body .md-text-align-center{text-align:center !important;}body .md-text-align-left{text-align:left !important;}body .md-text-align-right{text-align:right !important;}body .md-text-align-justify{text-align:justify !important;}body .md-flex-align-center{justify-content:center !important;}body .md-flex-align-flex-start{justify-content:flex-start !important;}body .md-flex-align-flex-end{justify-content:flex-end !important;}body .md-mx-auto{margin-left:auto !important;margin-right:auto !important;}body .md-ml-auto{margin-left:auto !important;}body .md-mr-auto{margin-right:auto !important;}body .fusion-absolute-position-medium{position:absolute;width:100%;}.awb-sticky.awb-sticky-medium{ position: sticky; top: var(--awb-sticky-offset,0); }}@media screen and (min-width: 801px){.fusion-no-large-visibility{display:none !important;}body .lg-text-align-center{text-align:center !important;}body .lg-text-align-left{text-align:left !important;}body .lg-text-align-right{text-align:right !important;}body .lg-text-align-justify{text-align:justify !important;}body .lg-flex-align-center{justify-content:center !important;}body .lg-flex-align-flex-start{justify-content:flex-start !important;}body .lg-flex-align-flex-end{justify-content:flex-end !important;}body .lg-mx-auto{margin-left:auto !important;margin-right:auto !important;}body .lg-ml-auto{margin-left:auto !important;}body .lg-mr-auto{margin-right:auto !important;}body .fusion-absolute-position-large{position:absolute;width:100%;}.awb-sticky.awb-sticky-large{ position: sticky; top: var(--awb-sticky-offset,0); }}</style>		<style type="text/css" id="wp-custom-css">
			.fusion-form-form-wrapper .fusion-form-field .fusion-form-checkbox input  {
	opacity: 1;
	position: static;
}



.menu-item.bordo-fluo > a {
  color: #00f7ff;
  text-shadow: 0 0 5px #00f7ff, 0 0 10px #00f7ff;
  transition: text-shadow 0.3s ease, color 0.3s ease;
}

.menu-item.bordo-fluo > a:hover {
  text-shadow: 0 0 10px #00f7ff, 0 0 20px #00f7ff;
  color: #a8faff; /* tonalità più chiara per il passaggio hover */
}


/* Accessibilità per icona nel menu */
.accessibility {
    font-size: 30px;
}		</style>
				<script type="text/javascript">
			var doc = document.documentElement;
			doc.setAttribute( 'data-useragent', navigator.userAgent );
		</script>
		
	</head>

<body data-rsssl=1 class="home wp-singular page-template page-template-100-width page-template-100-width-php page page-id-750 wp-theme-Avada fusion-image-hovers fusion-pagination-sizing fusion-button_type-flat fusion-button_span-no fusion-button_gradient-linear avada-image-rollover-circle-yes avada-image-rollover-yes avada-image-rollover-direction-bottom fusion-body ltr fusion-sticky-header no-tablet-sticky-header no-mobile-sticky-header fusion-disable-outline fusion-sub-menu-fade mobile-logo-pos-left layout-wide-mode avada-has-boxed-modal-shadow-none layout-scroll-offset-full avada-has-zero-margin-offset-top fusion-top-header menu-text-align-left mobile-menu-design-modern fusion-show-pagination-text fusion-header-layout-v1 avada-responsive avada-footer-fx-none avada-menu-highlight-style-bar fusion-search-form-classic fusion-main-menu-search-dropdown fusion-avatar-square avada-dropdown-styles avada-blog-layout-large avada-blog-archive-layout-medium avada-header-shadow-no avada-menu-icon-position-left avada-has-megamenu-shadow avada-has-mainmenu-dropdown-divider avada-has-breadcrumb-mobile-hidden avada-has-titlebar-hide avada-has-pagination-padding avada-has-slider-fallback-image avada-flyout-menu-direction-fade avada-ec-views-v1" data-awb-post-id="750">
		<a class="skip-link screen-reader-text" href="#content">Salta al contenuto</a>

	<div id="boxed-wrapper">
		
		<div id="wrapper" class="fusion-wrapper">
			<div id="home" style="position:relative;top:-1px;"></div>
														<div id="sliders-container" class="fusion-slider-visibility fusion-no-small-visibility fusion-no-medium-visibility">
			<div id="fusion-slider-17" data-id="17" class="fusion-slider-container fusion-slider-750" style="height:400px;max-width:100%;">
	<style type="text/css">
		#fusion-slider-17 .flex-direction-nav a {width:63px;height:63px;line-height:63px;font-size:25px;}	</style>
	<div class="fusion-slider-loading">Loading...</div>
		<div class="tfs-slider flexslider main-flex" style="max-width:100%;--typography_sensitivity:1.1;" data-slider_width="100%" data-slider_height="400px" data-full_screen="1" data-parallax="1" data-nav_arrows="0" data-autoplay="0" data-loop="1" data-animation="fade" data-slideshow_speed="7000" data-animation_speed="600" data-slider_content_width="" data-nav_box_width="63px" data-nav_box_height="63px" data-nav_arrow_size="25px" data-typo_sensitivity="1.1" data-typo_factor="1.5" data-slider_indicator="" data-slider_indicator_color="#ffffff" data-orderby="date" data-order="DESC" >
		<ul class="slides" style="max-width:100%;">
															<li class="slide-id-22" data-mute="yes" data-loop="yes" data-autoplay="yes">
					<div class="slide-content-container slide-content-center" style="display: none;">
						<div class="slide-content" style="">
															<div class="heading ">
									<div class="fusion-title-sc-wrapper fusion-block-element" style="">
										<div class="fusion-title title fusion-title-1 sep-underline sep-solid fusion-title-center fusion-title-text fusion-title-size-two" style="--awb-text-color:#ffffff;--awb-margin-bottom:0px;--awb-sep-color:#ffffff;--awb-font-size:70px;"><h2 class="fusion-title-heading title-heading-center fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;font-size:1em;--fontSize:70;line-height:1.2;">Gas.Net Group</h2></div>									</div>
								</div>
																						<div class="caption ">
									<div class="fusion-title-sc-wrapper" style="">
										<div class="fusion-title title fusion-title-2 fusion-sep-none fusion-title-center fusion-title-text fusion-title-size-three" style="--awb-text-color:#ffffff;--awb-margin-bottom:0px;--awb-sep-color:#ffffff;--awb-font-size:22px;"><h3 class="fusion-title-heading title-heading-center fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;font-size:1em;--fontSize:22;--minFontSize:22;line-height:1.2;">Consulenza | Progettazione | Applicazioni | Intelligenza Artificiale</h3></div>									</div>
								</div>
																				</div>
					</div>
																					<div class="mobile_video_image" style="background-image: url('https://gasnetgroup.it/wp-content/uploads/2023/09/Screenshot_233.png');"></div>
																<div class="overlay" style="background-color:rgba(86,86,86,0.4)"></div>
										<div class="background self-hosted-video-bg" style="max-width:100%;height:400px;filter: progid:DXImageTransform.Microsoft.AlphaImageLoader(src='', sizingMethod='scale');" data-imgwidth="">
													<span
								class="fusion-slider-self-hosted-video-placeholder"
								data-ogg=""
								data-webm=""
								data-mp4="https://gasnetgroup.it/wp-content/uploads/2023/09/gasnetgroup-front.mp4"
								muted loop								preload="auto"
							></span>
																							</div>
				</li>
					</ul>
	</div>
</div>
		</div>
				<div class="fusion-tb-header"><div class="fusion-fullwidth fullwidth-box fusion-builder-row-1 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling fusion-sticky-container fusion-custom-z-index" style="--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-z-index:9999;--awb-padding-top:0px;--awb-padding-bottom:0px;--awb-padding-top-small:15px;--awb-padding-bottom-small:15px;--awb-margin-bottom:0px;--awb-min-height:60px;--awb-background-color:var(--awb-color8);--awb-flex-wrap:wrap;" data-transition-offset="100" data-scroll-offset="0" data-sticky-large-visibility="1" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-center fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-0 fusion_builder_column_1_4 1_4 fusion-flex-column fusion-column-inner-bg-wrapper" style="--awb-inner-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:25%;--awb-order-medium:0;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:75%;--awb-order-small:0;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-row fusion-content-nowrap"><div class="fusion-image-element " style="--awb-margin-right:10px;--awb-max-width:250px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><span class=" has-fusion-standard-logo fusion-imageframe imageframe-none imageframe-1 hover-type-none"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/" target="_self"><img decoding="async" src="https://gasnetgroup.it/wp-content/uploads/2023/08/logo-gasnet.group_bianco_70px.png" srcset="https://gasnetgroup.it/wp-content/uploads/2023/08/logo-gasnet.group_bianco_70px.png 1x, 2x" style="max-height:70px;height:auto;" width="154" height="70" class="img-responsive fusion-standard-logo disable-lazyload" alt="GasNet Group Logo" /></a></span></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-1 fusion_builder_column_3_4 3_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:75%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:75%;--awb-order-medium:0;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:25%;--awb-order-small:0;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><nav class="awb-menu awb-menu_row awb-menu_em-hover mobile-mode-collapse-to-button awb-menu_icons-left awb-menu_dc-yes mobile-trigger-fullwidth-off awb-menu_mobile-toggle awb-menu_indent-left mobile-size-full-absolute loading mega-menu-loading awb-menu_desktop awb-menu_dropdown awb-menu_expand-right awb-menu_transition-fade" style="--awb-font-size:var(--awb-typography3-font-size);--awb-gap:45px;--awb-justify-content:flex-end;--awb-items-padding-top:35px;--awb-items-padding-bottom:35px;--awb-border-top:1px;--awb-color:hsla(var(--awb-color7-h),var(--awb-color7-s),calc( var(--awb-color7-l) + 61% ),var(--awb-color7-a));--awb-letter-spacing:var(--awb-typography3-letter-spacing);--awb-active-color:var(--awb-color1);--awb-active-border-top:1px;--awb-active-border-color:var(--awb-color1);--awb-submenu-color:var(--awb-color1);--awb-submenu-bg:var(--awb-color8);--awb-submenu-sep-color:rgba(226,226,226,0);--awb-submenu-active-bg:var(--awb-color5);--awb-submenu-active-color:var(--awb-color1);--awb-submenu-font-size:var(--awb-typography3-font-size);--awb-icons-color:hsla(var(--awb-color7-h),var(--awb-color7-s),calc( var(--awb-color7-l) + 61% ),var(--awb-color7-a));--awb-icons-hover-color:var(--awb-color1);--awb-main-justify-content:flex-start;--awb-mobile-nav-button-align-hor:flex-end;--awb-mobile-bg:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));--awb-mobile-color:var(--awb-color1);--awb-mobile-active-bg:var(--awb-color5);--awb-mobile-active-color:var(--awb-color1);--awb-mobile-trigger-font-size:40px;--awb-trigger-padding-top:0px;--awb-trigger-padding-right:0px;--awb-trigger-padding-bottom:0px;--awb-trigger-padding-left:0px;--awb-mobile-trigger-color:var(--awb-color1);--awb-mobile-trigger-background-color:rgba(255,255,255,0);--awb-mobile-nav-trigger-bottom-margin:15px;--awb-mobile-sep-color:rgba(0,0,0,0);--awb-sticky-min-height:70px;--awb-mobile-justify:flex-start;--awb-mobile-caret-left:auto;--awb-mobile-caret-right:0;--awb-fusion-font-family-typography:var(--awb-typography3-font-family);--awb-fusion-font-weight-typography:var(--awb-typography3-font-weight);--awb-fusion-font-style-typography:var(--awb-typography3-font-style);--awb-fusion-font-family-submenu-typography:var(--awb-typography3-font-family);--awb-fusion-font-weight-submenu-typography:var(--awb-typography3-font-weight);--awb-fusion-font-style-submenu-typography:var(--awb-typography3-font-style);--awb-fusion-font-family-mobile-typography:inherit;--awb-fusion-font-style-mobile-typography:normal;--awb-fusion-font-weight-mobile-typography:400;" aria-label="Menu" data-breakpoint="830" data-count="0" data-transition-type="center" data-transition-time="300" data-expand="right"><button type="button" class="awb-menu__m-toggle awb-menu__m-toggle_no-text" aria-expanded="false" aria-controls="menu-taxi-main-menu"><span class="awb-menu__m-toggle-inner"><span class="collapsed-nav-text"><span class="screen-reader-text">Toggle Navigation</span></span><span class="awb-menu__m-collapse-icon awb-menu__m-collapse-icon_no-text"><span class="awb-menu__m-collapse-icon-open awb-menu__m-collapse-icon-open_no-text architecture-menu"></span><span class="awb-menu__m-collapse-icon-close awb-menu__m-collapse-icon-close_no-text architecture-close"></span></span></span></button><ul id="menu-architecture-main-menu" class="fusion-menu awb-menu__main-ul awb-menu__main-ul_row"><li  id="menu-item-20"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-has-children menu-item-20 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="20"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/chi-siamo/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">CHI SIAMO</span><span class="awb-menu__open-nav-submenu-hover"></span></a><button type="button" aria-label="Open submenu of CHI SIAMO" aria-expanded="false" class="awb-menu__open-nav-submenu_mobile awb-menu__open-nav-submenu_main"></button><ul class="awb-menu__sub-ul awb-menu__sub-ul_main"><li  id="menu-item-1058"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1058 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/certificazioni/" class="awb-menu__sub-a"><span>CERTIFICAZIONI</span></a></li></ul></li><li  id="menu-item-133408"  class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-133408 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="133408"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="#" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">SOLUZIONI</span><span class="awb-menu__open-nav-submenu-hover"></span></a><button type="button" aria-label="Open submenu of SOLUZIONI" aria-expanded="false" class="awb-menu__open-nav-submenu_mobile awb-menu__open-nav-submenu_main"></button><ul class="awb-menu__sub-ul awb-menu__sub-ul_main"><li  id="menu-item-133409"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-133409 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/consulenza-project-management/" class="awb-menu__sub-a"><span>Consulenza &#038; Project management</span></a></li><li  id="menu-item-133410"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-133410 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/progettazione-sicurezza-infrastrutture-it/" class="awb-menu__sub-a"><span>Progettazione &#038; Sicurezza infrastrutture IT</span></a></li><li  id="menu-item-133426"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-133426 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/applicazioni-software/" class="awb-menu__sub-a"><span>Applicazioni Software</span></a></li><li  id="menu-item-133425"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-133425 awb-menu__li awb-menu__sub-li" ><a  href="https://gasnetgroup.it/intelligenza-artificiale/" class="awb-menu__sub-a"><span>Intelligenza Artificiale</span></a></li></ul></li><li  id="menu-item-832"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-832 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="832"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/area-clienti/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">AREA CLIENTI</span></a></li><li  id="menu-item-17"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-17 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="17"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/contatti/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">CONTATTI</span></a></li><li  id="menu-item-1377"  class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1377 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-item-id="1377"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/lavora-con-noi/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">LAVORA CON NOI</span></a></li><li  id="menu-item-133401"  class="bordo-fluo menu-item menu-item-type-post_type menu-item-object-page menu-item-133401 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-classes="bordo-fluo" data-item-id="133401"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  href="https://gasnetgroup.it/staff-ai/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text">STAFF AI</span></a></li><li  id="menu-item-133456"  class="accessibility menu-item menu-item-type-custom menu-item-object-custom menu-item-133456 awb-menu__li awb-menu__main-li awb-menu__main-li_regular"  data-classes="accessibility" data-item-id="133456"><span class="awb-menu__main-background-default awb-menu__main-background-default_center"></span><span class="awb-menu__main-background-active awb-menu__main-background-active_center"></span><a  title="Accessibility" target="_blank" rel="noopener noreferrer" href="https://gasnetgroup.it/contattaci-accessibility/" class="awb-menu__main-a awb-menu__main-a_regular"><span class="menu-text"><i class="fa-solid fa-universal-access"></i></span></a></li></ul></nav></div></div></div></div>
</div>							
			
						<main id="main" class="clearfix width-100">
				<div class="fusion-row" style="max-width:100%;">
<section id="content" class="full-width">
					<div id="post-750" class="post-750 page type-page status-publish hentry">
			<span class="entry-title rich-snippet-hidden">GasNet Group</span><span class="vcard rich-snippet-hidden"><span class="fn"><a href="https://gasnetgroup.it/author/g4sn3t_4dm1n/" title="Articoli scritti da g4sn3t_4dm1n" rel="author">g4sn3t_4dm1n</a></span></span><span class="updated rich-snippet-hidden">2025-03-25T16:03:33+00:00</span>						<div class="post-content">
				<div class="fusion-fullwidth fullwidth-box fusion-builder-row-2 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-background-position:left top;--awb-border-sizes-top:0;--awb-border-sizes-bottom:0;--awb-border-sizes-left:0;--awb-border-sizes-right:0;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:60px;--awb-padding-bottom:50px;--awb-padding-top-small:29px;--awb-padding-bottom-small:31px;--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-2 fusion_builder_column_1_3 1_3 fusion-flex-column" style="--awb-padding-bottom-small:0px;--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-width-large:33.333333333333%;--awb-margin-top-large:0px;--awb-spacing-right-large:5.76%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:5.76%;--awb-width-medium:100%;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-spacing-right-small:1.92%;--awb-margin-bottom-small:7px;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-3 fusion-sep-none fusion-title-text fusion-title-size-two" style="--awb-margin-bottom:50px;--awb-font-size:36px;"><h2 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;font-size:1em;--fontSize:36;line-height:var(--awb-typography1-line-height);">SOLUZIONI <span style="color: #0877a5;">INNOVATIVE</span></h2></div><div class="fusion-separator" style="align-self: flex-start;margin-right:auto;margin-top:0px;margin-bottom:40px;width:100%;max-width:170px;"><div class="fusion-separator-border sep-single sep-solid" style="--awb-height:20px;--awb-amount:20px;--awb-sep-color:var(--awb-color3);border-color:var(--awb-color3);border-top-width:3px;"></div></div><div class="fusion-text fusion-text-1" style="--awb-font-size:var(--awb-typography2-font-size);--awb-line-height:var(--awb-typography2-line-height);--awb-letter-spacing:var(--awb-typography2-letter-spacing);--awb-text-transform:var(--awb-typography2-text-transform);--awb-text-font-family:var(--awb-typography2-font-family);--awb-text-font-weight:var(--awb-typography2-font-weight);--awb-text-font-style:var(--awb-typography2-font-style);"></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-3 fusion_builder_column_2_3 2_3 fusion-flex-column" style="--awb-padding-top-small:0px;--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-width-large:66.666666666667%;--awb-margin-top-large:0px;--awb-spacing-right-large:2.88%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:3.84%;--awb-width-medium:100%;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-margin-top-small:2px;--awb-spacing-right-small:1.92%;--awb-margin-bottom-small:6px;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-text fusion-text-2" style="--awb-content-alignment:left;--awb-font-size:22px;--awb-line-height:1.9;--awb-letter-spacing:0px;--awb-text-font-family:var(--awb-typography2-font-family);--awb-text-font-weight:var(--awb-typography2-font-weight);--awb-text-font-style:var(--awb-typography2-font-style);"><p>Da oltre 25 anni, <b>Gas.Net Group Srl</b> è un punto di riferimento nel settore IT, offrendo servizi di <b>consulenza</b>, <b>progettazione</b>, <b>applicazioni </b>e soluzioni di <b>intelligenza artificiale</b>. Specializzati in soluzioni digitali per il settore sanitario e il terzo settore, supportiamo le aziende nella trasformazione digitale attraverso un approccio integrato e personalizzato. </p>
</div></div></div></div></div><div class="fusion-bg-parallax" data-bg-align="center center" data-direction="left" data-mute="false" data-opacity="100" data-velocity="-0.7" data-mobile-enabled="false" data-break_parents="0" data-bg-image="https://gasnetgroup.it/wp-content/uploads/2023/08/CONSULTING-PROJECT-MANAGEMENT-slide-Gasnet-Group-1-scaled.jpg" data-bg-repeat="false" ></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-3 fusion-flex-container fusion-parallax-left nonhundred-percent-fullwidth non-hundred-percent-height-scrolling lazyload" style="--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-color:transparent;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:70px;--awb-padding-bottom:70px;--awb-background-size:cover;--awb-flex-wrap:wrap;" data-bg="https://gasnetgroup.it/wp-content/uploads/2023/08/CONSULTING-PROJECT-MANAGEMENT-slide-Gasnet-Group-1-scaled.jpg" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-4 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height fusion-column-inner-bg-wrapper" style="--awb-padding-top:40px;--awb-padding-bottom:40px;--awb-inner-bg-blend:overlay;--awb-inner-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/consulenza-project-management/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-4 fusion-sep-none fusion-title-text fusion-title-size-three" style="--awb-text-color:var(--awb-color1);--awb-margin-bottom:0px;"><h3 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;--fontSize:32;line-height:var(--awb-typography1-line-height);">CONSULENZA &amp; PROJECT MANAGEMENT<br /></h3></div></div></div></div></div><div class="fusion-bg-parallax" data-bg-align="center center" data-direction="right" data-mute="false" data-opacity="100" data-velocity="-0.7" data-mobile-enabled="false" data-break_parents="0" data-bg-image="https://gasnetgroup.it/wp-content/uploads/2023/08/SECURITY-NETWORKING-slide-Gasnet-Group-1-scaled.jpg" data-bg-repeat="false" ></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-4 fusion-flex-container fusion-parallax-right nonhundred-percent-fullwidth non-hundred-percent-height-scrolling lazyload" style="--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-color:transparent;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:70px;--awb-padding-bottom:70px;--awb-background-size:cover;--awb-flex-wrap:wrap;" data-bg="https://gasnetgroup.it/wp-content/uploads/2023/08/SECURITY-NETWORKING-slide-Gasnet-Group-1-scaled.jpg" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-5 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height fusion-column-inner-bg-wrapper" style="--awb-padding-top:40px;--awb-padding-bottom:40px;--awb-inner-bg-blend:overlay;--awb-inner-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/progettazione-sicurezza-infrastrutture-it/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-5 fusion-sep-none fusion-title-text fusion-title-size-three" style="--awb-text-color:var(--awb-color1);--awb-margin-bottom:0px;"><h3 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;--fontSize:32;line-height:var(--awb-typography1-line-height);">PROGETTAZIONE &amp; SICUREZZA INFRASTRUTTURE IT</h3></div></div></div></div></div><div class="fusion-bg-parallax" data-bg-align="center center" data-direction="left" data-mute="false" data-opacity="100" data-velocity="-0.7" data-mobile-enabled="false" data-break_parents="0" data-bg-image="https://gasnetgroup.it/wp-content/uploads/2023/08/SOFTWARE-APP-DEVELOPMENT-slide-Gasnet-Group-1-scaled.jpg" data-bg-repeat="false" ></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-5 fusion-flex-container fusion-parallax-left nonhundred-percent-fullwidth non-hundred-percent-height-scrolling lazyload" style="--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-color:transparent;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:70px;--awb-padding-bottom:70px;--awb-background-size:cover;--awb-flex-wrap:wrap;" data-bg="https://gasnetgroup.it/wp-content/uploads/2023/08/SOFTWARE-APP-DEVELOPMENT-slide-Gasnet-Group-1-scaled.jpg" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-6 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height fusion-column-inner-bg-wrapper" style="--awb-padding-top:40px;--awb-padding-bottom:40px;--awb-inner-bg-blend:overlay;--awb-inner-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/sviluppo-software-app/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-6 fusion-sep-none fusion-title-text fusion-title-size-three" style="--awb-text-color:var(--awb-color1);--awb-margin-bottom:0px;"><h3 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;--fontSize:32;line-height:var(--awb-typography1-line-height);">APPLICAZIONI SOFTWARE<br /></h3></div></div></div></div></div><div class="fusion-bg-parallax" data-bg-align="center center" data-direction="left" data-mute="false" data-opacity="100" data-velocity="-0.7" data-mobile-enabled="false" data-break_parents="0" data-bg-image="https://gasnetgroup.it/wp-content/uploads/2025/02/SOLUZIONI-AI-SU-MISURA-slide-Gasnet-Group-scaled.jpg" data-bg-repeat="false" ></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-6 fusion-flex-container fusion-parallax-left nonhundred-percent-fullwidth non-hundred-percent-height-scrolling lazyload" style="--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-color:transparent;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:70px;--awb-padding-bottom:70px;--awb-background-size:cover;--awb-flex-wrap:wrap;" data-bg="https://gasnetgroup.it/wp-content/uploads/2025/02/SOLUZIONI-AI-SU-MISURA-slide-Gasnet-Group-scaled.jpg" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:calc( 1170px + 0px );margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-7 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height fusion-column-inner-bg-wrapper" style="--awb-padding-top:40px;--awb-padding-bottom:40px;--awb-inner-bg-blend:overlay;--awb-inner-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><span class="fusion-column-inner-bg hover-type-none"><a class="fusion-column-anchor" href="https://gasnetgroup.it/intelligenza-artificiale/"><span class="fusion-column-inner-bg-image"></span></a></span><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-7 fusion-sep-none fusion-title-text fusion-title-size-three" style="--awb-text-color:var(--awb-color1);--awb-margin-bottom:0px;"><h3 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;--fontSize:32;line-height:var(--awb-typography1-line-height);">INTELLIGENZA ARTIFICIALE</h3></div></div></div></div></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-7 fusion-flex-container hundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-overflow:visible;--awb-margin-top:-5px;--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="width:calc( 100% + 0px ) !important;max-width:calc( 100% + 0px ) !important;margin-left: calc(-0px / 2 );margin-right: calc(-0px / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-8 fusion_builder_column_1_1 1_1 fusion-flex-column fusion-flex-align-self-flex-start fusion-column-no-min-height" style="--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:0px;--awb-margin-bottom-large:0px;--awb-spacing-left-large:0px;--awb-width-medium:100%;--awb-spacing-right-medium:0px;--awb-spacing-left-medium:0px;--awb-width-small:100%;--awb-spacing-right-small:0px;--awb-spacing-left-small:0px;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-separator fusion-full-width-sep" style="align-self: flex-start;margin-right:auto;width:100%;"></div></div></div></div></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-8 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-background-position:left top;--awb-border-sizes-top:0px;--awb-border-sizes-bottom:0px;--awb-border-sizes-left:0px;--awb-border-sizes-right:0px;--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:42px;--awb-padding-bottom:20px;--awb-padding-top-small:50px;--awb-padding-bottom-small:0px;--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-center fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-9 fusion_builder_column_1_3 1_3 fusion-flex-column" style="--awb-bg-position:right center;--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-border-color:var(--awb-color4);--awb-border-right:3px;--awb-border-style:solid;--awb-width-large:33.333333333333%;--awb-margin-top-large:0px;--awb-spacing-right-large:3.84%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:5.76%;--awb-width-medium:100%;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-title title fusion-title-8 fusion-sep-none fusion-title-text fusion-title-size-two" style="--awb-margin-bottom:20px;--awb-margin-bottom-small:0px;--awb-margin-bottom-medium:0px;--awb-font-size:45px;"><h2 class="fusion-title-heading title-heading-left fusion-responsive-typography-calculated" style="margin:0;text-transform:capitalize;font-size:1em;--fontSize:45;line-height:var(--awb-typography1-line-height);"><span style="font-size: 43px;" data-fusion-font="true">LE NOSTRE <span style="font-size: 42px; color: var(--awb-color5);" data-fusion-font="true">CERTIFICAZION</span></span><span style="font-size: 42px; color: var(--awb-color5);" data-fusion-font="true">I</span></h2></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-10 fusion_builder_column_2_3 2_3 fusion-flex-column" style="--awb-bg-blend:overlay;--awb-bg-size:cover;--awb-width-large:66.666666666667%;--awb-margin-top-large:20px;--awb-spacing-right-large:2.88%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:3.84%;--awb-width-medium:100%;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-text fusion-text-3" style="--awb-font-size:var(--awb-typography2-font-size);--awb-line-height:1.6;--awb-letter-spacing:var(--awb-typography2-letter-spacing);--awb-text-transform:var(--awb-typography2-text-transform);--awb-text-font-family:var(--awb-typography2-font-family);--awb-text-font-weight:var(--awb-typography2-font-weight);--awb-text-font-style:var(--awb-typography2-font-style);"><p>Da sempre Gas.Net Group lavora secondo elevati standard qualitativi monitorando processi e prestazioni conseguendo le Certificazioni <span style="color: var(--awb-color5);">ISO 9001</span> e <span style="color: var(--awb-color5);">ISO/IEC 27001</span></p>
</div></div></div></div></div>
<div class="fusion-fullwidth fullwidth-box fusion-builder-row-9 fusion-flex-container has-pattern-background has-mask-background nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-bottom:43px;--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-11 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="--awb-liftup-border-radius:0px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><div class="awb-image-frame awb-image-frame-2 imageframe-liftup"><span class=" fusion-imageframe imageframe-glow imageframe-2" style="-webkit-box-shadow: 0 0 4px rgba(40,40,40,0.3);box-shadow: 0 0 4px rgba(40,40,40,0.3);"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/certificazioni/" target="_self" aria-label="ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105"><img fetchpriority="high" decoding="async" width="1729" height="2445" src="https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg" alt class="lazyload img-responsive wp-image-133177" srcset="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%271729%27%20height%3D%272445%27%20viewBox%3D%270%200%201729%202445%27%3E%3Crect%20width%3D%271729%27%20height%3D%272445%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-srcset="https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-200x283.jpg 200w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-400x566.jpg 400w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-600x848.jpg 600w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-800x1131.jpg 800w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105-1200x1697.jpg 1200w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISO-9001-10000469457-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg 1729w" data-sizes="auto" data-orig-sizes="(max-width: 800px) 100vw, (max-width: 640px) 100vw, 400px" /></a></span></div></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-12 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="--awb-liftup-border-radius:0px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><div class="awb-image-frame awb-image-frame-3 imageframe-liftup"><span class=" fusion-imageframe imageframe-glow imageframe-3" style="-webkit-box-shadow: 0 0 4px rgba(40,40,40,0.3);box-shadow: 0 0 4px rgba(40,40,40,0.3);"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/certificazioni/" target="_self" aria-label="ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105"><img decoding="async" width="1729" height="2445" src="https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg" alt class="lazyload img-responsive wp-image-133176" srcset="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%271729%27%20height%3D%272445%27%20viewBox%3D%270%200%201729%202445%27%3E%3Crect%20width%3D%271729%27%20height%3D%272445%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-srcset="https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-200x283.jpg 200w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-400x566.jpg 400w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-600x848.jpg 600w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-800x1131.jpg 800w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105-1200x1697.jpg 1200w, https://gasnetgroup.it/wp-content/uploads/2024/11/ISOIEC-27001-10000469456-MSC-ACCREDIA-ITA-1-en-US-20241105.jpg 1729w" data-sizes="auto" data-orig-sizes="(max-width: 800px) 100vw, (max-width: 640px) 100vw, 400px" /></a></span></div></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-13 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="--awb-liftup-border-radius:0px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><div class="awb-image-frame awb-image-frame-4 imageframe-liftup"><span class=" fusion-imageframe imageframe-glow imageframe-4" style="-webkit-box-shadow: 0 0 4px rgba(40,40,40,0.3);box-shadow: 0 0 4px rgba(40,40,40,0.3);"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/certificazioni/" target="_self" aria-label="IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654"><img decoding="async" width="1729" height="2445" src="https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654.jpg" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654.jpg" alt class="lazyload img-responsive wp-image-1001" srcset="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%271729%27%20height%3D%272445%27%20viewBox%3D%270%200%201729%202445%27%3E%3Crect%20width%3D%271729%27%20height%3D%272445%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-srcset="https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-200x283.jpg 200w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-400x566.jpg 400w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-600x848.jpg 600w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-800x1131.jpg 800w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654-1200x1697.jpg 1200w, https://gasnetgroup.it/wp-content/uploads/2023/08/IEC-27001-10000469456-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135654.jpg 1729w" data-sizes="auto" data-orig-sizes="(max-width: 800px) 100vw, (max-width: 640px) 100vw, 400px" /></a></span></div></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-14 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:20px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="--awb-liftup-border-radius:0px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><div class="awb-image-frame awb-image-frame-5 imageframe-liftup"><span class=" fusion-imageframe imageframe-glow imageframe-5" style="-webkit-box-shadow: 0 0 4px rgba(40,40,40,0.3);box-shadow: 0 0 4px rgba(40,40,40,0.3);"><a class="fusion-no-lightbox" href="https://gasnetgroup.it/certificazioni/" target="_self" aria-label="ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744"><img decoding="async" width="1729" height="2445" src="https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744.jpg" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744.jpg" alt class="lazyload img-responsive wp-image-1000" srcset="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%271729%27%20height%3D%272445%27%20viewBox%3D%270%200%201729%202445%27%3E%3Crect%20width%3D%271729%27%20height%3D%272445%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-srcset="https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-200x283.jpg 200w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-400x566.jpg 400w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-600x848.jpg 600w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-800x1131.jpg 800w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744-1200x1697.jpg 1200w, https://gasnetgroup.it/wp-content/uploads/2023/08/ISO-9001-10000469457-MSC-ACCREDIA-ITA-0-en-US-20211109-20211109135744.jpg 1729w" data-sizes="auto" data-orig-sizes="(max-width: 800px) 100vw, (max-width: 640px) 100vw, 400px" /></a></span></div></div></div></div></div></div>
							</div>
												</div>
	</section>
						
					</div>  <!-- fusion-row -->
				</main>  <!-- #main -->
				
				
								
					<div class="fusion-tb-footer fusion-footer"><div class="fusion-footer-widget-area fusion-widget-area"><div class="fusion-fullwidth fullwidth-box fusion-builder-row-10 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:20px;--awb-padding-bottom:20px;--awb-padding-top-small:20px;--awb-padding-bottom-small:20px;--awb-background-color:var(--awb-color8);--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-flex-start fusion-flex-justify-content-center fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-15 fusion_builder_column_1_3 1_3 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:33.333333333333%;--awb-margin-top-large:0px;--awb-spacing-right-large:5.76%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:5.76%;--awb-width-medium:50%;--awb-order-medium:0;--awb-spacing-right-medium:3.84%;--awb-spacing-left-medium:3.84%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-margin-bottom-small:30px;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-social-links fusion-social-links-1" style="--awb-margin-top:0px;--awb-margin-right:0px;--awb-margin-bottom:0px;--awb-margin-left:0px;--awb-margin-top-small:20px;--awb-box-border-top:0px;--awb-box-border-right:0px;--awb-box-border-bottom:0px;--awb-box-border-left:0px;--awb-icon-colors-hover:var(--awb-color5);--awb-box-colors-hover:var(--awb-color7);--awb-box-border-color:var(--awb-color3);--awb-box-border-color-hover:var(--awb-color4);--awb-alignment-small:center;"><div class="fusion-social-networks boxed-icons color-type-custom"><div class="fusion-social-networks-wrapper"><a class="fusion-social-network-icon fusion-tooltip fusion-facebook awb-icon-facebook" style="color:var(--awb-color4);font-size:21px;width:21px;background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-radius:99px;" data-placement="top" data-title="Facebook" data-toggle="tooltip" title="Facebook" aria-label="facebook" target="_blank" rel="noopener noreferrer" href="http://www.facebook.com/GasNetGroup"></a><a class="fusion-social-network-icon fusion-tooltip fusion-instagram awb-icon-instagram" style="color:var(--awb-color4);font-size:21px;width:21px;background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-radius:99px;" data-placement="top" data-title="Instagram" data-toggle="tooltip" title="Instagram" aria-label="instagram" target="_blank" rel="noopener noreferrer" href="https://www.instagram.com/gasnetgroup"></a><a class="fusion-social-network-icon fusion-tooltip fusion-youtube awb-icon-youtube" style="color:var(--awb-color4);font-size:21px;width:21px;background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-radius:99px;" data-placement="top" data-title="YouTube" data-toggle="tooltip" title="YouTube" aria-label="youtube" target="_blank" rel="noopener noreferrer" href="http://www.youtube.com/user/GasNetGroup"></a><a class="fusion-social-network-icon fusion-tooltip fusion-linkedin awb-icon-linkedin" style="color:var(--awb-color4);font-size:21px;width:21px;background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 10%),var(--awb-color8-a));border-radius:99px;" data-placement="top" data-title="LinkedIn" data-toggle="tooltip" title="LinkedIn" aria-label="linkedin" target="_blank" rel="noopener noreferrer" href="https://www.linkedin.com/company/gas-net-group-srl"></a></div></div></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-16 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="sm-text-align-center"><a class="fusion-button button-flat fusion-button-default-size button-custom fusion-button-default button-1 fusion-button-default-span fusion-button-default-type" style="--button_accent_color:#ffffff;--button_border_color:rgba(255,255,255,0);--button_accent_hover_color:var(--awb-color6);--button_border_hover_color:var(--awb-color6);--button_gradient_top_color:rgba(255,255,255,0);--button_gradient_bottom_color:rgba(255,255,255,0);--button_gradient_top_color_hover:hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 96.5% ));--button_gradient_bottom_color_hover:hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 96.5% ));" target="_self"  049 0 title=" 049 5384759 " aria-label=" 049 5384759 " href="tel:+390495384759"><i class="fa-phone fas awb-button__icon awb-button__icon--default button-icon-left" aria-hidden="true"></i><span class="fusion-button-text awb-button__text awb-button__text--default"> 049 5384759 </span></a></div></div></div><div class="fusion-layout-column fusion_builder_column fusion-builder-column-17 fusion_builder_column_1_4 1_4 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:25%;--awb-margin-top-large:0px;--awb-spacing-right-large:7.68%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:7.68%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="sm-text-align-center"><a class="fusion-button button-flat fusion-button-default-size button-custom fusion-button-default button-2 fusion-button-default-span fusion-button-default-type" style="--button_accent_color:#ffffff;--button_border_color:rgba(255,255,255,0);--button_accent_hover_color:var(--awb-color6);--button_border_hover_color:var(--awb-color6);--button_gradient_top_color:rgba(255,255,255,0);--button_gradient_bottom_color:rgba(255,255,255,0);--button_gradient_top_color_hover:hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 96.5% ));--button_gradient_bottom_color_hover:hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 96.5% ));" target="_self" EMAIL US title="EMAIL US" aria-label="EMAIL US" href="mailto:commerciale@gasnetgroup.com"><i class="fa-envelope fas awb-button__icon awb-button__icon--default button-icon-left" aria-hidden="true"></i><span class="fusion-button-text awb-button__text awb-button__text--default">EMAIL US</span></a></div></div></div></div></div><div class="fusion-fullwidth fullwidth-box fusion-builder-row-11 fusion-flex-container nonhundred-percent-fullwidth non-hundred-percent-height-scrolling" style="--link_color: hsla(var(--awb-color1-h),var(--awb-color1-s),var(--awb-color1-l),calc( var(--awb-color1-a) - 24% ));--awb-border-radius-top-left:0px;--awb-border-radius-top-right:0px;--awb-border-radius-bottom-right:0px;--awb-border-radius-bottom-left:0px;--awb-padding-top:15px;--awb-padding-bottom:15px;--awb-background-color:hsla(var(--awb-color8-h),var(--awb-color8-s),calc(var(--awb-color8-l) + 5%),var(--awb-color8-a));--awb-flex-wrap:wrap;" ><div class="fusion-builder-row fusion-row fusion-flex-align-items-center fusion-flex-content-wrap" style="max-width:1216.8px;margin-left: calc(-4% / 2 );margin-right: calc(-4% / 2 );"><div class="fusion-layout-column fusion_builder_column fusion-builder-column-18 fusion_builder_column_1_1 1_1 fusion-flex-column" style="--awb-bg-size:cover;--awb-width-large:100%;--awb-margin-top-large:0px;--awb-spacing-right-large:1.92%;--awb-margin-bottom-large:0px;--awb-spacing-left-large:1.92%;--awb-width-medium:100%;--awb-order-medium:0;--awb-spacing-right-medium:1.92%;--awb-spacing-left-medium:1.92%;--awb-width-small:100%;--awb-order-small:0;--awb-spacing-right-small:1.92%;--awb-spacing-left-small:1.92%;"><div class="fusion-column-wrapper fusion-column-has-shadow fusion-flex-justify-content-flex-start fusion-content-layout-column"><div class="fusion-image-element " style="text-align:center;--awb-margin-top:5px;--awb-margin-bottom:5px;--awb-max-width:150px;--awb-caption-title-font-family:var(--h2_typography-font-family);--awb-caption-title-font-weight:var(--h2_typography-font-weight);--awb-caption-title-font-style:var(--h2_typography-font-style);--awb-caption-title-size:var(--h2_typography-font-size);--awb-caption-title-transform:var(--h2_typography-text-transform);--awb-caption-title-line-height:var(--h2_typography-line-height);--awb-caption-title-letter-spacing:var(--h2_typography-letter-spacing);"><span class=" fusion-imageframe imageframe-none imageframe-6 hover-type-none"><img decoding="async" width="100" height="45" alt="GasNet Group" title="Gas.Net Group" src="data:image/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27100%27%20height%3D%2745%27%20viewBox%3D%270%200%20100%2045%27%3E%3Crect%20width%3D%27100%27%20height%3D%2745%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E" data-orig-src="https://gasnetgroup.it/wp-content/uploads/2023/08/logo-gasnet.group_bianco_45px.png" class="lazyload img-responsive wp-image-820"/></span></div><div class="fusion-text fusion-text-4 fusion-text-no-margin" style="--awb-font-size:12px;--awb-text-color:#787878;"><p style="text-align: center;">Gas.Net Group srl &#8211; Via Roma, 1 35020 Tribano (PD)<br />
Tel. 049 5384759 &#8211; P.Iva e Cod. Fiscale: 03306860283</p>
</div><div class="fusion-text fusion-text-5 md-text-align-center sm-text-align-center" style="--awb-font-size:12px;--awb-line-height:0;--awb-text-color:hsla(var(--awb-color7-h),var(--awb-color7-s),calc( var(--awb-color7-l) + 27% ),var(--awb-color7-a));"><p style="text-align: center;"><a href="https://gasnetgroup.it/certificazioni/">Azienda Certificata ISO 9001 e ISO/IEC 27001</a></p>
</div><div class="fusion-text fusion-text-6" style="--awb-font-size:12px;"><p style="text-align: center;"><a href="https://gasnetgroup.it/newsletter/"><b>ISCRIVITI ALLA NEWSLETTER</b></a><br />
@ Gas.Net Group <span class="awb-dd awb-dd-1"><span class="awb-dd-params">2026</span></span>. Tutti i diritti riservati.<br />
<a href="https://gasnetgroup.it/privacy-policy/">Privacy Policy</a> | <a href="https://gasnetgroup.it/cookie-policy/">Cookie Policy</a></p>
</div></div></div></div></div>
</div></div>
																</div> <!-- wrapper -->
		</div> <!-- #boxed-wrapper -->
				<a class="fusion-one-page-text-link fusion-page-load-link" tabindex="-1" href="#" aria-hidden="true">Page load link</a>

		<div class="avada-footer-scripts">
			<script type="text/javascript">var fusionNavIsCollapsed=function(e){var t,n;window.innerWidth<=e.getAttribute("data-breakpoint")?(e.classList.add("collapse-enabled"),e.classList.remove("awb-menu_desktop"),e.classList.contains("expanded")||window.dispatchEvent(new CustomEvent("fusion-mobile-menu-collapsed",{detail:{nav:e}})),(n=e.querySelectorAll(".menu-item-has-children.expanded")).length&&n.forEach(function(e){e.querySelector(".awb-menu__open-nav-submenu_mobile").setAttribute("aria-expanded","false")})):(null!==e.querySelector(".menu-item-has-children.expanded .awb-menu__open-nav-submenu_click")&&e.querySelector(".menu-item-has-children.expanded .awb-menu__open-nav-submenu_click").click(),e.classList.remove("collapse-enabled"),e.classList.add("awb-menu_desktop"),null!==e.querySelector(".awb-menu__main-ul")&&e.querySelector(".awb-menu__main-ul").removeAttribute("style")),e.classList.add("no-wrapper-transition"),clearTimeout(t),t=setTimeout(()=>{e.classList.remove("no-wrapper-transition")},400),e.classList.remove("loading")},fusionRunNavIsCollapsed=function(){var e,t=document.querySelectorAll(".awb-menu");for(e=0;e<t.length;e++)fusionNavIsCollapsed(t[e])};function avadaGetScrollBarWidth(){var e,t,n,l=document.createElement("p");return l.style.width="100%",l.style.height="200px",(e=document.createElement("div")).style.position="absolute",e.style.top="0px",e.style.left="0px",e.style.visibility="hidden",e.style.width="200px",e.style.height="150px",e.style.overflow="hidden",e.appendChild(l),document.body.appendChild(e),t=l.offsetWidth,e.style.overflow="scroll",t==(n=l.offsetWidth)&&(n=e.clientWidth),document.body.removeChild(e),jQuery("html").hasClass("awb-scroll")&&10<t-n?10:t-n}fusionRunNavIsCollapsed(),window.addEventListener("fusion-resize-horizontal",fusionRunNavIsCollapsed);</script><script type="speculationrules">
{"prefetch":[{"source":"document","where":{"and":[{"href_matches":"/*"},{"not":{"href_matches":["/wp-*.php","/wp-admin/*","/wp-content/uploads/*","/wp-content/*","/wp-content/plugins/*","/wp-content/themes/Avada/*","/*\\?(.+)"]}},{"not":{"selector_matches":"a[rel~=\"nofollow\"]"}},{"not":{"selector_matches":".no-prefetch, .no-prefetch a"}}]},"eagerness":"conservative"}]}
</script>

            <script type="text/javascript">
            document.addEventListener("DOMContentLoaded", function () {
                setTimeout(function () {
                    var s = document.createElement("script");
                    s.src = "https://cdn.jotfor.ms/agent/embedjs/0196cf368923737cba8ea4f8e67833e1f584/embed.js?skipWelcome=1&#038;maximizable=1";
                    s.defer = true;
                    document.head.appendChild(s);
                }, 2000);
            });
            </script>
        <script type="text/javascript" src="https://gasnetgroup.it/wp-includes/js/jquery/jquery.min.js?ver=3.7.1" id="jquery-core-js"></script>
<script type="text/javascript" id="dlm-xhr-js-extra">
/* <![CDATA[ */
var dlmXHRtranslations = {"error":"An error occurred while trying to download the file. Please try again.","not_found":"Il download non esiste","no_file_path":"No file path defined.","no_file_paths":"Nessun percorso definito.","filetype":"Download is not allowed for this file type.","file_access_denied":"Access denied to this file.","access_denied":"Access denied. You do not have permission to download this file.","security_error":"Something is wrong with the file path.","file_not_found":"File non trovato."};
//# sourceURL=dlm-xhr-js-extra
/* ]]> */
</script>
<script type="text/javascript" id="dlm-xhr-js-before">
/* <![CDATA[ */
const dlmXHR = {"xhr_links":{"class":["download-link","download-button"]},"prevent_duplicates":true,"ajaxUrl":"https:\/\/gasnetgroup.it\/wp-admin\/admin-ajax.php"}; dlmXHRinstance = {}; const dlmXHRGlobalLinks = "https://gasnetgroup.it/download/"; const dlmNonXHRGlobalLinks = []; dlmXHRgif = "https://gasnetgroup.it/wp-includes/images/spinner.gif"; const dlmXHRProgress = "1"
//# sourceURL=dlm-xhr-js-before
/* ]]> */
</script>
<script type="text/javascript" src="https://gasnetgroup.it/wp-content/plugins/download-monitor/assets/js/dlm-xhr.min.js?ver=5.1.7" id="dlm-xhr-js"></script>
<script type="text/javascript" src="https://gasnetgroup.it/wp-content/uploads/fusion-scripts/d66a74ce6d808b403b6eea9d9828ef39.min.js?ver=3.14.2" id="fusion-scripts-js"></script>
				<script type="text/javascript">
				jQuery( document ).ready( function() {
					var ajaxurl = 'https://gasnetgroup.it/wp-admin/admin-ajax.php';
					if ( 0 < jQuery( '.fusion-login-nonce' ).length ) {
						jQuery.get( ajaxurl, { 'action': 'fusion_login_nonce' }, function( response ) {
							jQuery( '.fusion-login-nonce' ).html( response );
						});
					}
				});
				</script>
						</div>

			<section class="to-top-container to-top-right" aria-labelledby="awb-to-top-label">
		<a href="#" id="toTop" class="fusion-top-top-link">
			<span id="awb-to-top-label" class="screen-reader-text">Torna in cima</span>

					</a>
	</section>
		</body>
</html>

ADR;CHARSET=utf-8;ENCODING=QUOTED-PRINTABLE:;;;;;;
TEL:+393480481476
EMAIL:paolo.ramazzina@gasnetgroup.com
TITLE;CHARSET=utf-8;ENCODING=QUOTED-PRINTABLE:Systems Analyst
ORG;CHARSET=utf-8;ENCODING=QUOTED-PRINTABLE:Gas.Net Group
URL:https://gasnetgroup.it/
END:VCARD