

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-my-brush-green-orange-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'MY BRUSH GREEN & ORANGE',
      item_id: 'ITA_PRDE00032306W',
      price: '€4,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Accessori per la casa',
      item_category3: 'Accessori per la casa',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-my-brush-green-orange-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "MY BRUSH GREEN & ORANGE",
            "item_id": "ITA_PRDE00032306W",
            "price": "€4,99",
            "item_brand": "Stanhome",
            "item_category1": "Accessori per la casa",
            "item_category2": "household-accessories",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="9936683860301" data-product-name="MY BRUSH GREEN &amp; ORANGE"
  data-product-price="4.99"
  data-product-brand="Stanhome"
  data-product-category="Accessori per la casa"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_87402_1_7eca11d4-f6da-480f-8d05-da63a0824e80.jpg?v=1738058009&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_87402_1_7eca11d4-f6da-480f-8d05-da63a0824e80.jpg?v=1738058009&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_87402_1_7eca11d4-f6da-480f-8d05-da63a0824e80.jpg?v=1738058009&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_87402_1_7eca11d4-f6da-480f-8d05-da63a0824e80.jpg?v=1738058009&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_87402_1_7eca11d4-f6da-480f-8d05-da63a0824e80.jpg?v=1738058009&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_87402_1_7eca11d4-f6da-480f-8d05-da63a0824e80.jpg?v=1738058009 998w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_87402_1_7eca11d4-f6da-480f-8d05-da63a0824e80.jpg?v=1738058009&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="Visuale del prodotto Spazzola Multiuso"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="998"
                                    height="998"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936683860301" data-swaction="addToWishlist" data-product-id="9936683860301" data-variant-id="50928009838925" data-product-url="https://www.stanhome.it/products/my-brush-green-orange">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936683860301" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-50%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936683860301" >
                        <a href="/products/my-brush-green-orange" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936683860301" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936683860301 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936683860301">
                            Spazzola Multiuso 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        MY BRUSH GREEN &amp; ORANGE
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €4,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €4,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €10,00
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936683860301" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="50928009838925"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936683860301-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936683860301-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936683860301"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936683860301" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936683860301" data-swaction="addToWishlist" data-product-id="9936683860301" data-variant-id="50928009838925" data-product-url="https://www.stanhome.it/products/my-brush-green-orange">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Spazzola Multiuso
                        
                    </div>
                    <div class="card__variant-title">
                        MY BRUSH GREEN &amp; ORANGE
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Facilita la pulizia nelle zone più inaccessibili.</span></li><li><span>Resistente ed efficace a lungo termine.</span></li><li><span>La sua forma permette di raggiungere i punti più difficili.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936683860301" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="50928009838925"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936683860301-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936683860301-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936683860301"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€4,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936683860301" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-germ-trol-pulitoredisinfettante-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'GERM-TROL PULITOREDISINFETTANTE',
      item_id: 'ITA_PRDE00036769W',
      price: '€6,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura della casa',
      item_category3: 'Disinfettanti',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-germ-trol-pulitoredisinfettante-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "GERM-TROL PULITOREDISINFETTANTE",
            "item_id": "ITA_PRDE00036769W",
            "price": "€6,99",
            "item_brand": "Stanhome",
            "item_category1": "Disinfettanti",
            "item_category2": "household-cleaners",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="10573887275341" data-product-name="GERM-TROL PULITOREDISINFETTANTE"
  data-product-price="6.99"
  data-product-brand="Stanhome"
  data-product-category="Disinfettanti"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_95182_1_e9d16cc6-282e-40c6-8b85-a92529dec349.jpg?v=1773675827&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_95182_1_e9d16cc6-282e-40c6-8b85-a92529dec349.jpg?v=1773675827&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_95182_1_e9d16cc6-282e-40c6-8b85-a92529dec349.jpg?v=1773675827&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_95182_1_e9d16cc6-282e-40c6-8b85-a92529dec349.jpg?v=1773675827&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_95182_1_e9d16cc6-282e-40c6-8b85-a92529dec349.jpg?v=1773675827&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_95182_1_e9d16cc6-282e-40c6-8b85-a92529dec349.jpg?v=1773675827 998w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_95182_1_e9d16cc6-282e-40c6-8b85-a92529dec349.jpg?v=1773675827&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="GERM-TROL PULITOREDISINFETTANTE"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="998"
                                    height="998"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10573887275341" data-swaction="addToWishlist" data-product-id="10573887275341" data-variant-id="53515025711437" data-product-url="https://www.stanhome.it/products/germ-trol-pulitoredisinfettante">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10573887275341" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-52%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10573887275341" >
                        <a href="/products/germ-trol-pulitoredisinfettante" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10573887275341" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10573887275341 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10573887275341">
                            Pulitore Disinfettante Multiuso 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        GERM-TROL PULITOREDISINFETTANTE
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €6,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €6,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €14,50
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10573887275341" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="53515025711437"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10573887275341-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10573887275341-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10573887275341"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10573887275341" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10573887275341" data-swaction="addToWishlist" data-product-id="10573887275341" data-variant-id="53515025711437" data-product-url="https://www.stanhome.it/products/germ-trol-pulitoredisinfettante">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Pulitore Disinfettante Multiuso
                        
                    </div>
                    <div class="card__variant-title">
                        GERM-TROL PULITOREDISINFETTANTE
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Elimina il 99,9% dei batteri e dei funghi.</span></li><li><span>Agisce in soli 15 minuti.</span></li><li><span>Imballaggio completamente riciclabile.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10573887275341" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="53515025711437"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10573887275341-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10573887275341-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10573887275341"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€6,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10573887275341" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-kitchen-sponge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'KITCHEN SPONGE',
      item_id: 'ITA_PRDE00036789W',
      price: '€4,50',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura della casa',
      item_category3: 'Pulizia della cucina',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-kitchen-sponge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "KITCHEN SPONGE",
            "item_id": "ITA_PRDE00036789W",
            "price": "€4,50",
            "item_brand": "Stanhome",
            "item_category1": "Pulizia della cucina",
            "item_category2": "household-cleaners",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="10262758064461" data-product-name="KITCHEN SPONGE"
  data-product-price="4.5"
  data-product-brand="Stanhome"
  data-product-category="Pulizia della cucina"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_52398_1_c6bcea06-9ab6-4706-9f7d-48a14561d6ea.jpg?v=1757401596&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_52398_1_c6bcea06-9ab6-4706-9f7d-48a14561d6ea.jpg?v=1757401596&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_52398_1_c6bcea06-9ab6-4706-9f7d-48a14561d6ea.jpg?v=1757401596 499w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_52398_1_c6bcea06-9ab6-4706-9f7d-48a14561d6ea.jpg?v=1757401596&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="KITCHEN SPONGE"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="499"
                                    height="499"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10262758064461" data-swaction="addToWishlist" data-product-id="10262758064461" data-variant-id="52384708002125" data-product-url="https://www.stanhome.it/products/kitchen-sponge">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10262758064461" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-59%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10262758064461" >
                        <a href="/products/kitchen-sponge" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10262758064461" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10262758064461 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10262758064461">
                            Spugna Cucina Double-Face 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        KITCHEN SPONGE
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €4,50
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €4,50
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €11,00
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10262758064461" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="52384708002125"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10262758064461-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10262758064461-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10262758064461"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10262758064461" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10262758064461" data-swaction="addToWishlist" data-product-id="10262758064461" data-variant-id="52384708002125" data-product-url="https://www.stanhome.it/products/kitchen-sponge">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Spugna Cucina Double-Face
                        
                    </div>
                    <div class="card__variant-title">
                        KITCHEN SPONGE
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Durata prolungata.</span></li><li><span>Beneficia di una doppia efficacia: abrasiva e assorbente.</span></li><li><span>Lavabile in lavatrice a 40°C.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10262758064461" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="52384708002125"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10262758064461-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10262758064461-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10262758064461"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€4,50</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10262758064461" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-black-wash-750-ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'BLACK WASH 750 ML',
      item_id: 'ITA_PRDE00036867W',
      price: '€6,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Detersivo lavatrice',
      item_category3: '',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-black-wash-750-ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "BLACK WASH 750 ML",
            "item_id": "ITA_PRDE00036867W",
            "price": "€6,99",
            "item_brand": "Stanhome",
            "item_category1": "",
            "item_category2": "laundry",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="10337014219085" data-product-name="BLACK WASH 750 ML"
  data-product-price="6.99"
  data-product-brand="Stanhome"
  data-product-category=""
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_55444_1_988d1787-389f-4909-b3b8-ee63cd1a6fc1.jpg?v=1761640538&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_55444_1_988d1787-389f-4909-b3b8-ee63cd1a6fc1.jpg?v=1761640538&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_55444_1_988d1787-389f-4909-b3b8-ee63cd1a6fc1.jpg?v=1761640538&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_55444_1_988d1787-389f-4909-b3b8-ee63cd1a6fc1.jpg?v=1761640538&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_55444_1_988d1787-389f-4909-b3b8-ee63cd1a6fc1.jpg?v=1761640538&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_55444_1_988d1787-389f-4909-b3b8-ee63cd1a6fc1.jpg?v=1761640538&width=1066 1066w,//www.stanhome.it/cdn/shop/files/All_product_55444_1_988d1787-389f-4909-b3b8-ee63cd1a6fc1.jpg?v=1761640538 1200w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_55444_1_988d1787-389f-4909-b3b8-ee63cd1a6fc1.jpg?v=1761640538&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="BLACK WASH 750 ML"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="1200"
                                    height="1200"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10337014219085" data-swaction="addToWishlist" data-product-id="10337014219085" data-variant-id="52662641819981" data-product-url="https://www.stanhome.it/products/black-wash-750-ml">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10337014219085" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-50%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10337014219085" >
                        <a href="/products/black-wash-750-ml" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10337014219085" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10337014219085 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10337014219085">
                            Detersivo Esperto Neri E Scuri 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        BLACK WASH 750 ML
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €6,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €6,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €14,00
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10337014219085" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="52662641819981"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10337014219085-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10337014219085-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10337014219085"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10337014219085" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10337014219085" data-swaction="addToWishlist" data-product-id="10337014219085" data-variant-id="52662641819981" data-product-url="https://www.stanhome.it/products/black-wash-750-ml">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Detersivo Esperto Neri E Scuri
                        
                    </div>
                    <div class="card__variant-title">
                        BLACK WASH 750 ML
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Lava e protegge i colori neri e scuri grazie alla sua formula concentrata.</span></li><li><span>Preserva i colori originali dei capi e previene il trasferimento di colore.</span></li><li><span>Contiene l'80% di ingredienti di origine naturale.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10337014219085" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="52662641819981"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10337014219085-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10337014219085-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10337014219085"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€6,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10337014219085" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-scratchy-cloth-blue-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'SCRATCHY CLOTH BLUE',
      item_id: 'ITA_PRDE00032801W',
      price: '€4,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Accessori per la casa',
      item_category3: 'Accessori per la casa',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-scratchy-cloth-blue-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "SCRATCHY CLOTH BLUE",
            "item_id": "ITA_PRDE00032801W",
            "price": "€4,99",
            "item_brand": "Stanhome",
            "item_category1": "Accessori per la casa",
            "item_category2": "household-accessories",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="9936684450125" data-product-name="SCRATCHY CLOTH BLUE"
  data-product-price="4.99"
  data-product-brand="Stanhome"
  data-product-category="Accessori per la casa"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_56752_1_e15e2bd7-7485-42cb-8d54-36c35df1e415.jpg?v=1738058131&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_56752_1_e15e2bd7-7485-42cb-8d54-36c35df1e415.jpg?v=1738058131&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_56752_1_e15e2bd7-7485-42cb-8d54-36c35df1e415.jpg?v=1738058131&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_56752_1_e15e2bd7-7485-42cb-8d54-36c35df1e415.jpg?v=1738058131&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_56752_1_e15e2bd7-7485-42cb-8d54-36c35df1e415.jpg?v=1738058131&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_56752_1_e15e2bd7-7485-42cb-8d54-36c35df1e415.jpg?v=1738058131 998w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_56752_1_e15e2bd7-7485-42cb-8d54-36c35df1e415.jpg?v=1738058131&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="Visuale del prodotto Microfibra Doppia Tessitura Per Superfici Lavabili"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="998"
                                    height="998"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936684450125" data-swaction="addToWishlist" data-product-id="9936684450125" data-variant-id="50928012034381" data-product-url="https://www.stanhome.it/products/scratchy-cloth-blue">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936684450125" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-62%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936684450125" >
                        <a href="/products/scratchy-cloth-blue" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936684450125" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936684450125 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936684450125">
                            Microfibra Doppia Tessitura Per Superfici Lavabili 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        SCRATCHY CLOTH BLUE
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €4,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €4,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €13,00
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936684450125" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="50928012034381"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936684450125-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936684450125-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936684450125"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936684450125" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936684450125" data-swaction="addToWishlist" data-product-id="9936684450125" data-variant-id="50928012034381" data-product-url="https://www.stanhome.it/products/scratchy-cloth-blue">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Microfibra Doppia Tessitura Per Superfici Lavabili
                        
                    </div>
                    <div class="card__variant-title">
                        SCRATCHY CLOTH BLUE
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Adatta a tutte le superfici lavabili degli interni.</span></li><li><span>Il suo lato abrasivo permette di rimuovere lo sporco incrostato delle superfici.</span></li><li><span>Il suo lato liscio permette di far brillare le superfici.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936684450125" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="50928012034381"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936684450125-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936684450125-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936684450125"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€4,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936684450125" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-dish-soap-150-gr-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'DISH SOAP 150 GR',
      item_id: 'ITA_PRDE00035808W',
      price: '€4,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura della casa',
      item_category3: 'Pulizia della cucina',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-dish-soap-150-gr-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "DISH SOAP 150 GR",
            "item_id": "ITA_PRDE00035808W",
            "price": "€4,99",
            "item_brand": "Stanhome",
            "item_category1": "Pulizia della cucina",
            "item_category2": "household-cleaners",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="9936692314445" data-product-name="DISH SOAP 150 GR"
  data-product-price="4.99"
  data-product-brand="Stanhome"
  data-product-category="Pulizia della cucina"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_51524_1_3e476320-fccb-44f8-bbad-e26ae9e4fd07.jpg?v=1738060208&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_51524_1_3e476320-fccb-44f8-bbad-e26ae9e4fd07.jpg?v=1738060208&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_51524_1_3e476320-fccb-44f8-bbad-e26ae9e4fd07.jpg?v=1738060208&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_51524_1_3e476320-fccb-44f8-bbad-e26ae9e4fd07.jpg?v=1738060208&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_51524_1_3e476320-fccb-44f8-bbad-e26ae9e4fd07.jpg?v=1738060208&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_51524_1_3e476320-fccb-44f8-bbad-e26ae9e4fd07.jpg?v=1738060208&width=1066 1066w,//www.stanhome.it/cdn/shop/files/All_product_51524_1_3e476320-fccb-44f8-bbad-e26ae9e4fd07.jpg?v=1738060208 1200w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_51524_1_3e476320-fccb-44f8-bbad-e26ae9e4fd07.jpg?v=1738060208&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="Visuale del prodotto Sapone solido stoviglie"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="1200"
                                    height="1200"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936692314445" data-swaction="addToWishlist" data-product-id="9936692314445" data-variant-id="50928037265741" data-product-url="https://www.stanhome.it/products/dish-soap-150-gr">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936692314445" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-58%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936692314445" >
                        <a href="/products/dish-soap-150-gr" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936692314445" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936692314445 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936692314445">
                            Sapone solido stoviglie 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        DISH SOAP 150 GR
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €4,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €4,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €12,00
            
          </s>
        </span></div>
    <small class="unit-price caption">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span>€0,05</span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>g
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936692314445" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="50928037265741"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936692314445-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936692314445-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936692314445"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936692314445" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936692314445" data-swaction="addToWishlist" data-product-id="9936692314445" data-variant-id="50928037265741" data-product-url="https://www.stanhome.it/products/dish-soap-150-gr">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Sapone solido stoviglie
                        
                    </div>
                    <div class="card__variant-title">
                        DISH SOAP 150 GR
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Sgrassa efficacemente le stoviglie a mano.</span></li><li><span>Tecnologia anti-odore nella fragranza.</span></li><li><span>Contiene oltre il 95% di ingredienti di origine naturale.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936692314445" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="50928037265741"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936692314445-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936692314445-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936692314445"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€4,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936692314445" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-quick-polish-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'QUICK POLISH',
      item_id: 'ITA_PRDE00035642W',
      price: '€5,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura della casa',
      item_category3: 'Prodotti per spolverare',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-quick-polish-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "QUICK POLISH",
            "item_id": "ITA_PRDE00035642W",
            "price": "€5,99",
            "item_brand": "Stanhome",
            "item_category1": "Prodotti per spolverare",
            "item_category2": "household-cleaners",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="9936691855693" data-product-name="QUICK POLISH"
  data-product-price="5.99"
  data-product-brand="Stanhome"
  data-product-category="Prodotti per spolverare"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_30383_1_00409e83-9d5c-4848-8175-644217304f40.jpg?v=1738060099&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_30383_1_00409e83-9d5c-4848-8175-644217304f40.jpg?v=1738060099&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_30383_1_00409e83-9d5c-4848-8175-644217304f40.jpg?v=1738060099&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_30383_1_00409e83-9d5c-4848-8175-644217304f40.jpg?v=1738060099&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_30383_1_00409e83-9d5c-4848-8175-644217304f40.jpg?v=1738060099&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_30383_1_00409e83-9d5c-4848-8175-644217304f40.jpg?v=1738060099 998w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_30383_1_00409e83-9d5c-4848-8175-644217304f40.jpg?v=1738060099&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="Visuale del prodotto Pulitore Elimina-Polvere, Protettivo Multisuperficie"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="998"
                                    height="998"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936691855693" data-swaction="addToWishlist" data-product-id="9936691855693" data-variant-id="50928035266893" data-product-url="https://www.stanhome.it/products/quick-polish">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691855693" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-57%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691855693" >
                        <a href="/products/quick-polish" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691855693" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691855693 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691855693">
                            Pulitore Elimina-Polvere, Protettivo Multisuperficie 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        QUICK POLISH
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €5,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €5,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €14,00
            
          </s>
        </span></div>
    <small class="unit-price caption">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span>€14,98</span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>l
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691855693" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="50928035266893"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691855693-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691855693-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691855693"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936691855693" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936691855693" data-swaction="addToWishlist" data-product-id="9936691855693" data-variant-id="50928035266893" data-product-url="https://www.stanhome.it/products/quick-polish">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Pulitore Elimina-Polvere, Protettivo Multisuperficie
                        
                    </div>
                    <div class="card__variant-title">
                        QUICK POLISH
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Elimina in modo duraturo la polvere dalle superfici.</span></li><li><span>Protegge dalla polvere per almeno 5 giorni.</span></li><li><span>Lascia un profumo fresco e piacevole.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691855693" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="50928035266893"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691855693-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691855693-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691855693"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€5,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936691855693" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-no-stain-refill-500ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'NO STAIN REFILL 500ML',
      item_id: 'ITA_PRDE00035644W',
      price: '€4,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura della casa',
      item_category3: 'Detergente multiuso',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-no-stain-refill-500ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "NO STAIN REFILL 500ML",
            "item_id": "ITA_PRDE00035644W",
            "price": "€4,99",
            "item_brand": "Stanhome",
            "item_category1": "Detergente multiuso",
            "item_category2": "household-cleaners",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="10519885218125" data-product-name="NO STAIN REFILL 500ML"
  data-product-price="4.99"
  data-product-brand="Stanhome"
  data-product-category="Detergente multiuso"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_23696_1_f2defd5b-1100-451a-8640-5c3598625a15.jpg?v=1770720807&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_23696_1_f2defd5b-1100-451a-8640-5c3598625a15.jpg?v=1770720807&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_23696_1_f2defd5b-1100-451a-8640-5c3598625a15.jpg?v=1770720807&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_23696_1_f2defd5b-1100-451a-8640-5c3598625a15.jpg?v=1770720807&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_23696_1_f2defd5b-1100-451a-8640-5c3598625a15.jpg?v=1770720807&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_23696_1_f2defd5b-1100-451a-8640-5c3598625a15.jpg?v=1770720807&width=1066 1066w,//www.stanhome.it/cdn/shop/files/All_product_23696_1_f2defd5b-1100-451a-8640-5c3598625a15.jpg?v=1770720807 1600w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_23696_1_f2defd5b-1100-451a-8640-5c3598625a15.jpg?v=1770720807&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="NO STAIN REFILL 500ML"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="1600"
                                    height="1600"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10519885218125" data-swaction="addToWishlist" data-product-id="10519885218125" data-variant-id="53298102600013" data-product-url="https://www.stanhome.it/products/no-stain-refill-500ml">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10519885218125" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-58%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10519885218125" >
                        <a href="/products/no-stain-refill-500ml" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10519885218125" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10519885218125 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10519885218125">
                            Spray Espresso Macchie Tenaci 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        NO STAIN REFILL 500ML
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €4,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €4,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €12,00
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10519885218125" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="53298102600013"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10519885218125-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10519885218125-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10519885218125"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10519885218125" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10519885218125" data-swaction="addToWishlist" data-product-id="10519885218125" data-variant-id="53298102600013" data-product-url="https://www.stanhome.it/products/no-stain-refill-500ml">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Spray Espresso Macchie Tenaci
                        
                    </div>
                    <div class="card__variant-title">
                        NO STAIN REFILL 500ML
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Rapido ed efficace.</span></li><li><span>Per uso interno ed esterno.</span></li><li><span>Contiene oltre il 92% di ingredienti di origine naturale.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10519885218125" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="53298102600013"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10519885218125-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10519885218125-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10519885218125"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€4,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10519885218125" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-aquilaun-750-ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'AQUILAUN 750 ML',
      item_id: 'ITA_PRDE00034829W',
      price: '€6,50',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura del bucato',
      item_category3: 'Cura del bucato',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-aquilaun-750-ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "AQUILAUN 750 ML",
            "item_id": "ITA_PRDE00034829W",
            "price": "€6,50",
            "item_brand": "Stanhome",
            "item_category1": "Cura del bucato",
            "item_category2": "laundry-and-linen-care",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="9936688546125" data-product-name="AQUILAUN 750 ML"
  data-product-price="6.5"
  data-product-brand="Stanhome"
  data-product-category="Cura del bucato"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_57128_1_0cd710c6-27ff-44b3-a8dc-ef4051452ab5.jpg?v=1738059020&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_57128_1_0cd710c6-27ff-44b3-a8dc-ef4051452ab5.jpg?v=1738059020&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_57128_1_0cd710c6-27ff-44b3-a8dc-ef4051452ab5.jpg?v=1738059020&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_57128_1_0cd710c6-27ff-44b3-a8dc-ef4051452ab5.jpg?v=1738059020&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_57128_1_0cd710c6-27ff-44b3-a8dc-ef4051452ab5.jpg?v=1738059020&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_57128_1_0cd710c6-27ff-44b3-a8dc-ef4051452ab5.jpg?v=1738059020 998w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_57128_1_0cd710c6-27ff-44b3-a8dc-ef4051452ab5.jpg?v=1738059020&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="Visuale del prodotto Detersivo Esperto Lana E Delicati"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="998"
                                    height="998"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936688546125" data-swaction="addToWishlist" data-product-id="9936688546125" data-variant-id="50928022618445" data-product-url="https://www.stanhome.it/products/aquilaun-750-ml">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936688546125" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-52%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936688546125" >
                        <a href="/products/aquilaun-750-ml" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936688546125" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936688546125 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936688546125">
                            Detersivo Esperto Lana E Delicati 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        AQUILAUN 750 ML
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €6,50
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €6,50
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €13,50
            
          </s>
        </span></div>
    <small class="unit-price caption">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span>€8,67</span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>l
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936688546125" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="50928022618445"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936688546125-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936688546125-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936688546125"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936688546125" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936688546125" data-swaction="addToWishlist" data-product-id="9936688546125" data-variant-id="50928022618445" data-product-url="https://www.stanhome.it/products/aquilaun-750-ml">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Detersivo Esperto Lana E Delicati
                        
                    </div>
                    <div class="card__variant-title">
                        AQUILAUN 750 ML
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Pulisce e smacchia efficacemente i tessuti delicati.</span></li><li><span>La sua azione anti-infeltrimento permette di preservare la morbidezza e le fibre dei tessuti.</span></li><li><span>Contiene oltre l'87% di ingredienti di origine naturale.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936688546125" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="50928022618445"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936688546125-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936688546125-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936688546125"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€6,50</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936688546125" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-multi-surface-500-ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'MULTI-SURFACE 500 ML',
      item_id: 'ITA_PRDE00035109W',
      price: '€4,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura della casa',
      item_category3: 'Multiuso',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-multi-surface-500-ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "MULTI-SURFACE 500 ML",
            "item_id": "ITA_PRDE00035109W",
            "price": "€4,99",
            "item_brand": "Stanhome",
            "item_category1": "Multiuso",
            "item_category2": "household-cleaners",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="10197205647693" data-product-name="MULTI-SURFACE 500 ML"
  data-product-price="4.99"
  data-product-brand="Stanhome"
  data-product-category="Multiuso"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_91965_1_df5721b0-0fa2-4d74-8dfb-7a4057d00820.jpg?v=1754397387&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_91965_1_df5721b0-0fa2-4d74-8dfb-7a4057d00820.jpg?v=1754397387&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_91965_1_df5721b0-0fa2-4d74-8dfb-7a4057d00820.jpg?v=1754397387&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_91965_1_df5721b0-0fa2-4d74-8dfb-7a4057d00820.jpg?v=1754397387&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_91965_1_df5721b0-0fa2-4d74-8dfb-7a4057d00820.jpg?v=1754397387&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_91965_1_df5721b0-0fa2-4d74-8dfb-7a4057d00820.jpg?v=1754397387 998w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_91965_1_df5721b0-0fa2-4d74-8dfb-7a4057d00820.jpg?v=1754397387&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="MULTI-SURFACE 500 ML"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="998"
                                    height="998"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10197205647693" data-swaction="addToWishlist" data-product-id="10197205647693" data-variant-id="52174774403405" data-product-url="https://www.stanhome.it/products/multi-surface-500-ml">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10197205647693" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-58%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10197205647693" >
                        <a href="/products/multi-surface-500-ml" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10197205647693" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10197205647693 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10197205647693">
                            Pulitore Multisuperficie Cucina 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        MULTI-SURFACE 500 ML
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €4,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €4,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €12,00
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10197205647693" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="52174774403405"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10197205647693-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10197205647693-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10197205647693"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10197205647693" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_10197205647693" data-swaction="addToWishlist" data-product-id="10197205647693" data-variant-id="52174774403405" data-product-url="https://www.stanhome.it/products/multi-surface-500-ml">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Pulitore Multisuperficie Cucina
                        
                    </div>
                    <div class="card__variant-title">
                        MULTI-SURFACE 500 ML
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Pulisce e sgrassa le superfici lavabili della cucina.</span></li><li><span>Profumo dalle note dolci e acidule di bergamotto e tè.</span></li><li><span>Contiene oltre il 95% di ingredienti di origine naturale.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10197205647693" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="52174774403405"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10197205647693-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb10197205647693-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-10197205647693"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€4,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="10197205647693" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-laundry-soap-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'LAUNDRY SOAP',
      item_id: 'ITA_PRDE00035646W',
      price: '€3,99',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura del bucato',
      item_category3: 'Cura del bucato',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-laundry-soap-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "LAUNDRY SOAP",
            "item_id": "ITA_PRDE00035646W",
            "price": "€3,99",
            "item_brand": "Stanhome",
            "item_category1": "Cura del bucato",
            "item_category2": "laundry-and-linen-care",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="9955035840845" data-product-name="LAUNDRY SOAP"
  data-product-price="3.99"
  data-product-brand="Stanhome"
  data-product-category="Cura del bucato"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_26672_1_eb635a68-4b7d-4aa7-85ab-ce73454f71c6.jpg?v=1739864201&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_26672_1_eb635a68-4b7d-4aa7-85ab-ce73454f71c6.jpg?v=1739864201&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_26672_1_eb635a68-4b7d-4aa7-85ab-ce73454f71c6.jpg?v=1739864201&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_26672_1_eb635a68-4b7d-4aa7-85ab-ce73454f71c6.jpg?v=1739864201&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_26672_1_eb635a68-4b7d-4aa7-85ab-ce73454f71c6.jpg?v=1739864201&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_26672_1_eb635a68-4b7d-4aa7-85ab-ce73454f71c6.jpg?v=1739864201&width=1066 1066w,//www.stanhome.it/cdn/shop/files/All_product_26672_1_eb635a68-4b7d-4aa7-85ab-ce73454f71c6.jpg?v=1739864201 1600w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_26672_1_eb635a68-4b7d-4aa7-85ab-ce73454f71c6.jpg?v=1739864201&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="Visuale del prodotto Sapone Solido - Smacchiatore Bucato"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="1600"
                                    height="1600"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9955035840845" data-swaction="addToWishlist" data-product-id="9955035840845" data-variant-id="51016772845901" data-product-url="https://www.stanhome.it/products/laundry-soap">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9955035840845" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-60%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9955035840845" >
                        <a href="/products/laundry-soap" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9955035840845" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9955035840845 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9955035840845">
                            Sapone Solido - Smacchiatore Bucato 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        LAUNDRY SOAP
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €3,99
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €3,99
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €10,00
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9955035840845" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="51016772845901"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9955035840845-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9955035840845-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9955035840845"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9955035840845" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9955035840845" data-swaction="addToWishlist" data-product-id="9955035840845" data-variant-id="51016772845901" data-product-url="https://www.stanhome.it/products/laundry-soap">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Sapone Solido - Smacchiatore Bucato
                        
                    </div>
                    <div class="card__variant-title">
                        LAUNDRY SOAP
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Elimina tutti i tipi di macchie sui tessuti lavabili.</span></li><li><span>ll formato solido contribuisce al rispetto del pianeta.</span></li><li><span>Contiene oltre il 96% di ingredienti di origine naturale.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9955035840845" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="51016772845901"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9955035840845-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9955035840845-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9955035840845"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€3,99</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9955035840845" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>


<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841730107159" rel="stylesheet" type="text/css" media="all" />
<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-volume-pricing.css?v=57651460954306395331730107155" rel="stylesheet" type="text/css" media="all" />




<script>
  // Create Product List array
  if (!axProductList) {
    var axProductList = [];
  }

  // Create Product click array
  if (!axItem) {
    var axItem = [];
  }

  if (!listName) {
    var listName = '';
  } else {
    listName = '';
  }

  document.addEventListener('DOMContentLoaded', function () {
    // Onclick event
    var productCards = document.querySelectorAll('.gtm-card-product-all-in-one-shower-200-ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb');
    productCards.forEach(function (card) {
      if (card.closest('.gtm-tracking-crosssell') !== null) {
        listName = card.closest('.gtm-tracking-crosssell').getAttribute('gtm-tracking-crosssell');
      }
      card.addEventListener('click', function (event) {
        var productData = JSON.parse(card.getAttribute('gtm-card-data'));
        // Need to push listName
        productData['item_list_name'] = listName;
        // Push clicked product
        axItem.push(productData);
        // Send "click" event
        dataLayer.push({
          event: 'ax_product_click',
          axItem: axItem
        });
      });
    });

    // Push all product in dataLayer
    axProductList.push({
      item_name: 'ALL IN ONE SHOWER 200 ML',
      item_id: 'ITA_PRDE00035520W',
      price: '€5,90',
      item_brand: 'Stanhome',
      item_category1: 'Stanhome',
      item_category2: 'Cura dei capelli',
      item_category3: 'Cura del corpo',
      item_variant: 'Default Title',
      item_list_name: listName
    });

    // Send "finished" event
    if (axProductList.length === window.theme.items_count) {
      dataLayer.push({
        event: 'ax_product_list_complete',
        axProductList: axProductList,
      });
    }
  });

  function clickProduct(productData) {}
</script>


<script defer>
  function swymCallbackFn(swat) {
    document.addEventListener('swym:collections-loaded', function () {
      swat.initializeActionButtons('<<Collections Grid PARENT Selector >>');
    });
  }
  if (!window.SwymCallbacks) {
    window.SwymCallbacks = [];
  }
  window.SwymCallbacks.push(swymCallbackFn);
</script>


    

    <div class="card-wrapper product-miniature product-card-wrapper underline-links-hover gtm-card-product gtm-card-product-all-in-one-shower-200-ml-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb card-product" gtm-card-data='
        {
            "item_name": "ALL IN ONE SHOWER 200 ML",
            "item_id": "ITA_PRDE00035520W",
            "price": "€5,90",
            "item_brand": "Stanhome",
            "item_category1": "Cura del corpo",
            "item_category2": "hair-product",
            "item_category3": null,
            "item_variant": "Default Title"
        }
    ' data-product-id="9936691495245" data-product-name="ALL IN ONE SHOWER 200 ML"
  data-product-price="5.9"
  data-product-brand="Stanhome"
  data-product-category="Cura del corpo"
  data-product-position="">
        <div
                class="
        card card--standard
         card--media
        
        
        
        
        
      "
                style="--ratio-percent: 100%;"
        >
            <div
                    class="card__inner color-background-1 gradient ratio"
                    style="--ratio-percent: 100%;"
            ><div class="card__media">
                        <div class="media media--transparent">
                            
                            
                            <img srcset="//www.stanhome.it/cdn/shop/files/All_product_83700_1_94d52458-ca4b-434e-a972-0fafac13ffaa.jpg?v=1738060023&width=165 165w,//www.stanhome.it/cdn/shop/files/All_product_83700_1_94d52458-ca4b-434e-a972-0fafac13ffaa.jpg?v=1738060023&width=360 360w,//www.stanhome.it/cdn/shop/files/All_product_83700_1_94d52458-ca4b-434e-a972-0fafac13ffaa.jpg?v=1738060023&width=533 533w,//www.stanhome.it/cdn/shop/files/All_product_83700_1_94d52458-ca4b-434e-a972-0fafac13ffaa.jpg?v=1738060023&width=720 720w,//www.stanhome.it/cdn/shop/files/All_product_83700_1_94d52458-ca4b-434e-a972-0fafac13ffaa.jpg?v=1738060023&width=940 940w,//www.stanhome.it/cdn/shop/files/All_product_83700_1_94d52458-ca4b-434e-a972-0fafac13ffaa.jpg?v=1738060023 998w
                                            "
                                    src="//www.stanhome.it/cdn/shop/files/All_product_83700_1_94d52458-ca4b-434e-a972-0fafac13ffaa.jpg?v=1738060023&width=533"
                                    sizes="(min-width: 1600px) 367px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                                    alt="Visuale del prodotto Gel doccia viso, corpo, capelli Tutti i tipi di pelle e capelli"
                                    class="motion-reduce"
                                    loading="lazy"
                                    
                                        loading="lazy"
                                    
                                    width="998"
                                    height="998"
                            >
                            
</div>
                    </div><div class="card__content">
                    <!-- Swym Wishlist Plus EPI Button with default first variant -->
                    <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936691495245" data-swaction="addToWishlist" data-product-id="9936691495245" data-variant-id="50928034873677" data-product-url="https://www.stanhome.it/products/all-in-one-shower-200-ml">
                    </button>
                    <!-- Swym Wishlist Plus EPI Button-->
                    <div class="card__badge top left"><span id="Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691495245" class="badge badge--bottom-left color-scheme-d6a5c036-6c45-47cf-add6-badfefb45fd9">-64%
</span></div>
                </div>
            </div>
            <div class="card__content">
                <div class="card__information"><div class="card__type">
                            Stanhome
                        </div><p class="card__heading h5"  id="title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691495245" >
                        <a href="/products/all-in-one-shower-200-ml" id="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691495245" class="full-unstyled-link full-unstyled-link-product" aria-labelledby="CardLink-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691495245 Badge-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691495245">
                            Gel doccia viso, corpo, capelli Tutti i tipi di pelle e capelli 
                        </a>
                    </p>

                    <div class="card__variant-title">
                        ALL IN ONE SHOWER 200 ML
                    </div>
                    <div class="card-information"><span class="caption-large light"></span>

                        <div class="card__information-form-rating-price">
                            <div class="rating-price">
<div
  class="
    price  price--on-sale"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span class="price-item price-item--regular">
          €5,90
        </span></div>
    <div class="price__sale">
    <span class="visually-hidden visually-hidden--inline">Prezzo scontato</span>
      <span class="price-item price-item--sale price-item--last">
        €5,90
      </span>
        <span class="visually-hidden visually-hidden--inline">Prezzo di listino</span>
        <span>
          <s class="price-item price-item--regular">
            
              €16,50
            
          </s>
        </span></div>
    <small class="unit-price caption">
      <span class="visually-hidden">Prezzo unitario</span>
      <span class="price-item price-item-unit price-item--last">
        <span>€0,03</span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>ml
        </span>
      </span>
    </small>
  </div></div>

</div><div class="quick-add quick-add-mobile no-js-hidden extra-large-up-hide"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691495245" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                                    type="hidden"
                                                    name="id" data-productid=""
                                                    value="50928034873677"
                                                    class="product-variant-id"
                                                    
                                            >
                                            <button
                                                    id="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691495245-submit"
                                                    type="submit"
                                                    name="add"
                                                    class="quick-add__submit button button--full-width button--primary"
                                                    aria-haspopup="dialog"
                                                    aria-labelledby="quick-add-mobiletemplate--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691495245-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691495245"
                                                    aria-live="polite"
                                                    data-sold-out-message="true"
                                                    
                                            >
                                    <span><svg
  class="icon sh-icon-cart-empty"
  aria-hidden="true"
  focusable="false"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 18 22"
  fill="none"
>
  <path d="M16.419 4.713v14.348a2.609 2.609 0 0 1-2.609 2.607H3.376a2.609 2.609 0 0 1-2.609-2.607V4.713Z" stroke="currentColor"/>
  <path d="M4.647 7.321V4.712a3.946 3.946 0 1 1 7.891 0v2.609"  stroke="currentColor"/>
</svg>
  </span>
                                                <span class="sold-out-message hidden">
                                      Esaurito
                                    </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936691495245" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                                </div></div>
                    </div>
                </div>
            </div>
            <div class="card__content-hover">
                <!-- Swym Wishlist Plus EPI Button with default first variant -->
                <button aria-label="Add to Wishlist" data-with-epi="true" class="swym-button swym-add-to-wishlist-view-product product_9936691495245" data-swaction="addToWishlist" data-product-id="9936691495245" data-variant-id="50928034873677" data-product-url="https://www.stanhome.it/products/all-in-one-shower-200-ml">
                </button>
                <!-- Swym Wishlist Plus EPI Button-->
                <div class="card__information">
                    <div class="card__heading">
                        
                            Gel doccia viso, corpo, capelli Tutti i tipi di pelle e capelli
                        
                    </div>
                    <div class="card__variant-title">
                        ALL IN ONE SHOWER 200 ML
                    </div><ul class="list-unstyled card__variant-key_points"><li><span>Detergo e purifico viso, corpo e capelli in un solo lavaggio.</span></li><li><span>La sua base lavante senza sapone e senza solfati rispetta la pelle e il cuoio capelluto.</span></li><li><span>Contiene più del 90% d'ingredienti di origine naturale.</span></li></ul></div><div class="quick-add no-js-hidden"><product-form data-section-id="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb"><form method="post" action="/cart/add" id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691495245" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input
                                            type="hidden"
                                            name="id" data-productid=""
                                            value="50928034873677"
                                            class="product-variant-id"
                                            
                                    >
                                    <button
                                            id="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691495245-submit"
                                            type="submit"
                                            name="add"
                                            class="quick-add__submit button button--full-width button--primary"
                                            aria-haspopup="dialog"
                                            aria-labelledby="quick-add-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb9936691495245-submit title-template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb-9936691495245"
                                            aria-live="polite"
                                            data-sold-out-message="true"
                                            
                                    >
                                        <span>Aggiungi al carrello - <span class="button__price">€5,90</span></span>
                                        <span class="sold-out-message hidden">
                                          Esaurito
                                        </span>

<link href="//www.stanhome.it/cdn/shop/t/3/assets/component-loading-spinner.css?v=116724955567955766481730107161" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="9936691495245" /><input type="hidden" name="section-id" value="template--23762702991693__67d7dc4c-eab1-4ed2-a7bf-28066ff5ddcb" /></form></product-form>
                        
                    </div></div>
        </div>
    </div>