La Belle Boucle - Produits Naturels pour Cheveux Bouclés


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/pack-routine-cheveux-ondules-boucles"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8754974884188"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8754974884188 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8754974884188"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxondules.jpg?v=1708012305&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxondules.jpg?v=1708012305&width=165 165w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxondules.jpg?v=1708012305&width=360 360w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxondules.jpg?v=1708012305&width=533 533w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxondules.jpg?v=1708012305&width=720 720w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxondules.jpg?v=1708012305&width=940 940w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxondules.jpg?v=1708012305&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxondules.jpg?v=1708012305 3406w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Pack Routine Cheveux Ondulés/Bouclés"
										class="motion-reduce"
										
										width="3406"
										height="3407"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Pack Routine Cheveux Ondulés/Bouclés
								</div>
							</div>
							<div class="card__badge top left">
								
<span
										id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8754974884188"
										class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
									>Promotion</span>
								</div>
						</div>

						<!-- 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_8754974884188"
										data-swaction="addToWishlist"
										data-product-id="8754974884188"
										data-variant-id="47665609015644"
										data-product-url="https://labelleboucle.fr/products/pack-routine-cheveux-ondules-boucles"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8754974884188" 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"
												value="47665609015644"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8754974884188-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8754974884188-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8754974884188"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="8754974884188" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8754974884188"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8754974884188"
								
							>
								Pack Routine Cheveux Ondulés/Bouclés
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          56,70€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        56,70€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              63,00€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
<span
									id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8754974884188"
									class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
								>Promotion</span>
							</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/pack-routine-cheveux-boucles-frises"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8754975146332"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8754975146332 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8754975146332"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxboucles_frises.jpg?v=1708012352&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxboucles_frises.jpg?v=1708012352&width=165 165w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxboucles_frises.jpg?v=1708012352&width=360 360w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxboucles_frises.jpg?v=1708012352&width=533 533w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxboucles_frises.jpg?v=1708012352&width=720 720w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxboucles_frises.jpg?v=1708012352&width=940 940w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxboucles_frises.jpg?v=1708012352&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/Packroutinecheveuxboucles_frises.jpg?v=1708012352 3748w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Pack Routine Cheveux Bouclés/Frisés"
										class="motion-reduce"
										
										width="3748"
										height="3748"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Pack Routine Cheveux Bouclés/Frisés
								</div>
							</div>
							<div class="card__badge top left">
								
<span
										id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8754975146332"
										class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
									>Promotion</span>
								</div>
						</div>

						<!-- 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_8754975146332"
										data-swaction="addToWishlist"
										data-product-id="8754975146332"
										data-variant-id="47665609933148"
										data-product-url="https://labelleboucle.fr/products/pack-routine-cheveux-boucles-frises"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8754975146332" 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"
												value="47665609933148"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8754975146332-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8754975146332-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8754975146332"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="8754975146332" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8754975146332"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8754975146332"
								
							>
								Pack Routine Cheveux Bouclés/Frisés
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          77,40€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        77,40€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              86,00€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
<span
									id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8754975146332"
									class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
								>Promotion</span>
							</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/trio-coiffant"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9453263651164"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9453263651164 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9453263651164"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Trio_Coiffant_1370b695-02c1-4bed-8d23-95f55bf50eda.png?v=1719480550&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Trio_Coiffant_1370b695-02c1-4bed-8d23-95f55bf50eda.png?v=1719480550&width=165 165w,//labelleboucle.fr/cdn/shop/files/Trio_Coiffant_1370b695-02c1-4bed-8d23-95f55bf50eda.png?v=1719480550&width=360 360w,//labelleboucle.fr/cdn/shop/files/Trio_Coiffant_1370b695-02c1-4bed-8d23-95f55bf50eda.png?v=1719480550&width=533 533w,//labelleboucle.fr/cdn/shop/files/Trio_Coiffant_1370b695-02c1-4bed-8d23-95f55bf50eda.png?v=1719480550 700w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Trio Coiffant"
										class="motion-reduce"
										
										width="700"
										height="700"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Trio Coiffant
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
								
<span
										id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9453263651164"
										class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
									>Promotion</span>
								</div>
						</div>

						<!-- 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_9453263651164"
										data-swaction="addToWishlist"
										data-product-id="9453263651164"
										data-variant-id="48959693324636"
										data-product-url="https://labelleboucle.fr/products/trio-coiffant"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9453263651164" 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"
												value="48959693324636"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9453263651164-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9453263651164-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9453263651164"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9453263651164" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9453263651164"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9453263651164"
								
							>
								Trio Coiffant
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          54,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        54,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              60,00€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
							
<span
									id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9453263651164"
									class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
								>Promotion</span>
							</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/pack-multitexture-cheveux-ondules-boucles"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9634187510108"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9634187510108 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9634187510108"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxOndulesBoucles.png?v=1728569931&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxOndulesBoucles.png?v=1728569931&width=165 165w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxOndulesBoucles.png?v=1728569931&width=360 360w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxOndulesBoucles.png?v=1728569931&width=533 533w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxOndulesBoucles.png?v=1728569931&width=720 720w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxOndulesBoucles.png?v=1728569931&width=940 940w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxOndulesBoucles.png?v=1728569931&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxOndulesBoucles.png?v=1728569931 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Pack Multitextures Cheveux Ondulés/Bouclés"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Pack Multitextures Cheveux Ondulés/Bouclés
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
								
<span
										id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9634187510108"
										class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
									>Promotion</span>
								</div>
						</div>

						<!-- 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_9634187510108"
										data-swaction="addToWishlist"
										data-product-id="9634187510108"
										data-variant-id="49517609255260"
										data-product-url="https://labelleboucle.fr/products/pack-multitexture-cheveux-ondules-boucles"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9634187510108" 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"
												value="49517609255260"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9634187510108-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9634187510108-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9634187510108"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9634187510108" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9634187510108"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9634187510108"
								
							>
								Pack Multitextures Cheveux Ondulés/Bouclés
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          59,22€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        59,22€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              65,80€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
							
<span
									id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9634187510108"
									class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
								>Promotion</span>
							</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/pack-multitexture-cheveux-boucles-frises"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9634245607772"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9634245607772 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9634245607772"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxBouclesFrises_1.png?v=1728658163&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxBouclesFrises_1.png?v=1728658163&width=165 165w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxBouclesFrises_1.png?v=1728658163&width=360 360w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxBouclesFrises_1.png?v=1728658163&width=533 533w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxBouclesFrises_1.png?v=1728658163&width=720 720w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxBouclesFrises_1.png?v=1728658163&width=940 940w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxBouclesFrises_1.png?v=1728658163&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/PackMultitextureCheveuxBouclesFrises_1.png?v=1728658163 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Pack Multitextures Cheveux Bouclés/Frisés"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Pack Multitextures Cheveux Bouclés/Frisés
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
								
<span
										id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9634245607772"
										class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
									>Promotion</span>
								</div>
						</div>

						<!-- 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_9634245607772"
										data-swaction="addToWishlist"
										data-product-id="9634245607772"
										data-variant-id="49517827621212"
										data-product-url="https://labelleboucle.fr/products/pack-multitexture-cheveux-boucles-frises"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9634245607772" 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"
												value="49517827621212"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9634245607772-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9634245607772-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9634245607772"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9634245607772" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9634245607772"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9634245607772"
								
							>
								Pack Multitextures Cheveux Bouclés/Frisés
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          78,93€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        78,93€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              87,70€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
							
<span
									id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9634245607772"
									class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
								>Promotion</span>
							</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/masque-capillaire-belle-boucle"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952635236422"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952635236422 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952635236422"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/Belle-Boucle-3.png?v=1656631041&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/Belle-Boucle-3.png?v=1656631041&width=165 165w,//labelleboucle.fr/cdn/shop/products/Belle-Boucle-3.png?v=1656631041&width=360 360w,//labelleboucle.fr/cdn/shop/products/Belle-Boucle-3.png?v=1656631041&width=533 533w,//labelleboucle.fr/cdn/shop/products/Belle-Boucle-3.png?v=1656631041&width=720 720w,//labelleboucle.fr/cdn/shop/products/Belle-Boucle-3.png?v=1656631041&width=940 940w,//labelleboucle.fr/cdn/shop/products/Belle-Boucle-3.png?v=1656631041&width=1066 1066w,//labelleboucle.fr/cdn/shop/products/Belle-Boucle-3.png?v=1656631041 2364w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Masque Capillaire Belle Boucle en poudres"
										class="motion-reduce"
										
										width="2364"
										height="2363"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Masque Capillaire Belle Boucle en poudres
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
									
										
									
										
									
								
<span
										id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952635236422"
										class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
									>Promotion</span>
								</div>
						</div>

						<!-- 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_6952635236422"
										data-swaction="addToWishlist"
										data-product-id="6952635236422"
										data-variant-id="40167044808774"
										data-product-url="https://labelleboucle.fr/products/masque-capillaire-belle-boucle"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952635236422" 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"
												value="40167044808774"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952635236422-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952635236422-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952635236422"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6952635236422" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952635236422"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952635236422"
								
							>
								Masque Capillaire Belle Boucle en poudres
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          13,93€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        13,93€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              19,90€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -30%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
								
									
								
									
								
							
<span
									id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952635236422"
									class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
								>Promotion</span>
							</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/cure-croissance-complement-alimentaire-gelules"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8739335799132"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8739335799132 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8739335799132"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/GelulesLBB_3.png?v=1714398451&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/GelulesLBB_3.png?v=1714398451&width=165 165w,//labelleboucle.fr/cdn/shop/files/GelulesLBB_3.png?v=1714398451&width=360 360w,//labelleboucle.fr/cdn/shop/files/GelulesLBB_3.png?v=1714398451&width=533 533w,//labelleboucle.fr/cdn/shop/files/GelulesLBB_3.png?v=1714398451&width=720 720w,//labelleboucle.fr/cdn/shop/files/GelulesLBB_3.png?v=1714398451&width=940 940w,//labelleboucle.fr/cdn/shop/files/GelulesLBB_3.png?v=1714398451 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Cure Croissance Complément Alimentaire Gélules"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/Pack3moisGelules_2_1.png?v=1714398469&width=165 165w,//labelleboucle.fr/cdn/shop/files/Pack3moisGelules_2_1.png?v=1714398469&width=360 360w,//labelleboucle.fr/cdn/shop/files/Pack3moisGelules_2_1.png?v=1714398469&width=533 533w,//labelleboucle.fr/cdn/shop/files/Pack3moisGelules_2_1.png?v=1714398469&width=720 720w,//labelleboucle.fr/cdn/shop/files/Pack3moisGelules_2_1.png?v=1714398469&width=940 940w,//labelleboucle.fr/cdn/shop/files/Pack3moisGelules_2_1.png?v=1714398469 1000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/Pack3moisGelules_2_1.png?v=1714398469&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="1000"
											height="1000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Cure Croissance Complément Alimentaire Gélules
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8739335799132"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_8739335799132"
										data-swaction="addToWishlist"
										data-product-id="8739335799132"
										data-variant-id="47621386240348"
										data-product-url="https://labelleboucle.fr/products/cure-croissance-complement-alimentaire-gelules"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-8739335799132">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8739335799132-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8739335799132-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8739335799132"
											data-product-url="/products/cure-croissance-complement-alimentaire-gelules"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-8739335799132" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Cure Croissance Complément Alimentaire Gélules"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-8739335799132"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-8739335799132" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8739335799132"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8739335799132"
								
							>
								Cure Croissance Complément Alimentaire Gélules
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          67,50€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        67,50€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              75,00€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8739335799132"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/cure-croissance-complement-alimentaire-gummies"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8739371090268"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8739371090268 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8739371090268"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Gummies-LBB_1.png?v=1714399527&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Gummies-LBB_1.png?v=1714399527&width=165 165w,//labelleboucle.fr/cdn/shop/files/Gummies-LBB_1.png?v=1714399527&width=360 360w,//labelleboucle.fr/cdn/shop/files/Gummies-LBB_1.png?v=1714399527&width=533 533w,//labelleboucle.fr/cdn/shop/files/Gummies-LBB_1.png?v=1714399527&width=720 720w,//labelleboucle.fr/cdn/shop/files/Gummies-LBB_1.png?v=1714399527&width=940 940w,//labelleboucle.fr/cdn/shop/files/Gummies-LBB_1.png?v=1714399527 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Cure Croissance Complément Alimentaire Gummies"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/Gummiesx3.png?v=1714399562&width=165 165w,//labelleboucle.fr/cdn/shop/files/Gummiesx3.png?v=1714399562&width=360 360w,//labelleboucle.fr/cdn/shop/files/Gummiesx3.png?v=1714399562&width=533 533w,//labelleboucle.fr/cdn/shop/files/Gummiesx3.png?v=1714399562&width=720 720w,//labelleboucle.fr/cdn/shop/files/Gummiesx3.png?v=1714399562&width=940 940w,//labelleboucle.fr/cdn/shop/files/Gummiesx3.png?v=1714399562 1000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/Gummiesx3.png?v=1714399562&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="1000"
											height="1000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Cure Croissance Complément Alimentaire Gummies
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8739371090268"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_8739371090268"
										data-swaction="addToWishlist"
										data-product-id="8739371090268"
										data-variant-id="47621416321372"
										data-product-url="https://labelleboucle.fr/products/cure-croissance-complement-alimentaire-gummies"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-8739371090268">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8739371090268-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8739371090268-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8739371090268"
											data-product-url="/products/cure-croissance-complement-alimentaire-gummies"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-8739371090268" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Cure Croissance Complément Alimentaire Gummies"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-8739371090268"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-8739371090268" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8739371090268"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8739371090268"
								
							>
								Cure Croissance Complément Alimentaire Gummies
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          67,50€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        67,50€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              75,00€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8739371090268"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/complements-alimentaires-resolution-n1"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952623407174"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952623407174 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952623407174"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/complements-alimentaires-re_CC_81solution-n-1-madame-la-presidente.png?v=1656629745&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/complements-alimentaires-re_CC_81solution-n-1-madame-la-presidente.png?v=1656629745&width=165 165w,//labelleboucle.fr/cdn/shop/products/complements-alimentaires-re_CC_81solution-n-1-madame-la-presidente.png?v=1656629745&width=360 360w,//labelleboucle.fr/cdn/shop/products/complements-alimentaires-re_CC_81solution-n-1-madame-la-presidente.png?v=1656629745&width=533 533w,//labelleboucle.fr/cdn/shop/products/complements-alimentaires-re_CC_81solution-n-1-madame-la-presidente.png?v=1656629745&width=720 720w,//labelleboucle.fr/cdn/shop/products/complements-alimentaires-re_CC_81solution-n-1-madame-la-presidente.png?v=1656629745&width=940 940w,//labelleboucle.fr/cdn/shop/products/complements-alimentaires-re_CC_81solution-n-1-madame-la-presidente.png?v=1656629745 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Compléments Alimentaires Résolution N°1"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/products/complementalimentaire.png?v=1679066329&width=165 165w,//labelleboucle.fr/cdn/shop/products/complementalimentaire.png?v=1679066329&width=360 360w,//labelleboucle.fr/cdn/shop/products/complementalimentaire.png?v=1679066329&width=533 533w,//labelleboucle.fr/cdn/shop/products/complementalimentaire.png?v=1679066329&width=720 720w,//labelleboucle.fr/cdn/shop/products/complementalimentaire.png?v=1679066329&width=940 940w,//labelleboucle.fr/cdn/shop/products/complementalimentaire.png?v=1679066329 1000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/products/complementalimentaire.png?v=1679066329&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="1000"
											height="1000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Compléments Alimentaires Résolution N°1
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952623407174"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_6952623407174"
										data-swaction="addToWishlist"
										data-product-id="6952623407174"
										data-variant-id="46375688143196"
										data-product-url="https://labelleboucle.fr/products/complements-alimentaires-resolution-n1"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-6952623407174">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952623407174-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952623407174-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952623407174"
											data-product-url="/products/complements-alimentaires-resolution-n1"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-6952623407174" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Compléments Alimentaires Résolution N°1"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-6952623407174"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-6952623407174" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Madame La Présidente </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952623407174"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952623407174"
								
							>
								Compléments Alimentaires Résolution N°1
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          29,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        29,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952623407174"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/complements-alimentaires-gummies-hair-boost"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952626520134"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952626520134 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952626520134"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/New_Hair_Boost.png?v=1733749374&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/New_Hair_Boost.png?v=1733749374&width=165 165w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost.png?v=1733749374&width=360 360w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost.png?v=1733749374&width=533 533w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost.png?v=1733749374&width=720 720w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost.png?v=1733749374&width=940 940w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost.png?v=1733749374&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost.png?v=1733749374 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Compléments Alimentaires Gummies Hair Boost"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/New_Hair_Boost_-_3_mois.png?v=1733749378&width=165 165w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost_-_3_mois.png?v=1733749378&width=360 360w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost_-_3_mois.png?v=1733749378&width=533 533w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost_-_3_mois.png?v=1733749378&width=720 720w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost_-_3_mois.png?v=1733749378&width=940 940w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost_-_3_mois.png?v=1733749378&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/New_Hair_Boost_-_3_mois.png?v=1733749378 2000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/New_Hair_Boost_-_3_mois.png?v=1733749378&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="2000"
											height="2000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Compléments Alimentaires Gummies Hair Boost
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952626520134"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_6952626520134"
										data-swaction="addToWishlist"
										data-product-id="6952626520134"
										data-variant-id="46370584854876"
										data-product-url="https://labelleboucle.fr/products/complements-alimentaires-gummies-hair-boost"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-6952626520134">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952626520134-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952626520134-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952626520134"
											data-product-url="/products/complements-alimentaires-gummies-hair-boost"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-6952626520134" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Compléments Alimentaires Gummies Hair Boost"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-6952626520134"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-6952626520134" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Madame La Présidente </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952626520134"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952626520134"
								
							>
								Compléments Alimentaires Gummies Hair Boost
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          24,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        24,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952626520134"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/complements-alimentaires-gelules-pousse-de-cheveux"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952632123462"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952632123462 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952632123462"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/GelulesCheveuxPousse_Volume.png?v=1688991691&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/GelulesCheveuxPousse_Volume.png?v=1688991691&width=165 165w,//labelleboucle.fr/cdn/shop/files/GelulesCheveuxPousse_Volume.png?v=1688991691&width=360 360w,//labelleboucle.fr/cdn/shop/files/GelulesCheveuxPousse_Volume.png?v=1688991691&width=533 533w,//labelleboucle.fr/cdn/shop/files/GelulesCheveuxPousse_Volume.png?v=1688991691 700w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Compléments Alimentaires Gélules Pousse de Cheveux"
										class="motion-reduce"
										
										width="700"
										height="700"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/GeulesCheveuxPousseetVolumeInHaircare.png?v=1688991705&width=165 165w,//labelleboucle.fr/cdn/shop/files/GeulesCheveuxPousseetVolumeInHaircare.png?v=1688991705&width=360 360w,//labelleboucle.fr/cdn/shop/files/GeulesCheveuxPousseetVolumeInHaircare.png?v=1688991705&width=533 533w,//labelleboucle.fr/cdn/shop/files/GeulesCheveuxPousseetVolumeInHaircare.png?v=1688991705 700w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/GeulesCheveuxPousseetVolumeInHaircare.png?v=1688991705&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="700"
											height="700"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Compléments Alimentaires Gélules Pousse de Cheveux
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952632123462"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_6952632123462"
										data-swaction="addToWishlist"
										data-product-id="6952632123462"
										data-variant-id="46375644856668"
										data-product-url="https://labelleboucle.fr/products/complements-alimentaires-gelules-pousse-de-cheveux"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-6952632123462">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952632123462-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952632123462-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952632123462"
											data-product-url="/products/complements-alimentaires-gelules-pousse-de-cheveux"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-6952632123462" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Compléments Alimentaires Gélules Pousse de Cheveux"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-6952632123462"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-6952632123462" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">In Haircare </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952632123462"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952632123462"
								
							>
								Compléments Alimentaires Gélules Pousse de Cheveux
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          29,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        29,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952632123462"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/complements-croissance-cheveux"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952624881734"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952624881734 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952624881734"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/croissance-cheveux-boucles-crepus-les-secrets-de-loly-la-belle-boucle.png?v=1656629884&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/croissance-cheveux-boucles-crepus-les-secrets-de-loly-la-belle-boucle.png?v=1656629884&width=165 165w,//labelleboucle.fr/cdn/shop/products/croissance-cheveux-boucles-crepus-les-secrets-de-loly-la-belle-boucle.png?v=1656629884&width=360 360w,//labelleboucle.fr/cdn/shop/products/croissance-cheveux-boucles-crepus-les-secrets-de-loly-la-belle-boucle.png?v=1656629884&width=533 533w,//labelleboucle.fr/cdn/shop/products/croissance-cheveux-boucles-crepus-les-secrets-de-loly-la-belle-boucle.png?v=1656629884&width=720 720w,//labelleboucle.fr/cdn/shop/products/croissance-cheveux-boucles-crepus-les-secrets-de-loly-la-belle-boucle.png?v=1656629884&width=940 940w,//labelleboucle.fr/cdn/shop/products/croissance-cheveux-boucles-crepus-les-secrets-de-loly-la-belle-boucle.png?v=1656629884&width=1066 1066w,//labelleboucle.fr/cdn/shop/products/croissance-cheveux-boucles-crepus-les-secrets-de-loly-la-belle-boucle.png?v=1656629884 4000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Compléments Croissance Cheveux"
										class="motion-reduce"
										
										width="4000"
										height="4000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/products/lslcomplements.png?v=1679066469&width=165 165w,//labelleboucle.fr/cdn/shop/products/lslcomplements.png?v=1679066469&width=360 360w,//labelleboucle.fr/cdn/shop/products/lslcomplements.png?v=1679066469&width=533 533w,//labelleboucle.fr/cdn/shop/products/lslcomplements.png?v=1679066469&width=720 720w,//labelleboucle.fr/cdn/shop/products/lslcomplements.png?v=1679066469&width=940 940w,//labelleboucle.fr/cdn/shop/products/lslcomplements.png?v=1679066469 1000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/products/lslcomplements.png?v=1679066469&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="1000"
											height="1000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Compléments Croissance Cheveux
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952624881734"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_6952624881734"
										data-swaction="addToWishlist"
										data-product-id="6952624881734"
										data-variant-id="46375691551068"
										data-product-url="https://labelleboucle.fr/products/complements-croissance-cheveux"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-6952624881734">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952624881734-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952624881734-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952624881734"
											data-product-url="/products/complements-croissance-cheveux"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-6952624881734" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Compléments Croissance Cheveux"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-6952624881734"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-6952624881734" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952624881734"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952624881734"
								
							>
								Compléments Croissance Cheveux
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          20,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        20,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6952624881734"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/complements-alimentaires-vegan-hair-impulse"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8516055925084"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8516055925084 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8516055925084"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentairesCutByFred.png?v=1712758903&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentairesCutByFred.png?v=1712758903&width=165 165w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentairesCutByFred.png?v=1712758903&width=360 360w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentairesCutByFred.png?v=1712758903 500w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Compléments Alimentaires Vegan Hair Impulse"
										class="motion-reduce"
										
										width="500"
										height="500"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/Cutbyfred3mois.png?v=1712758929&width=165 165w,//labelleboucle.fr/cdn/shop/files/Cutbyfred3mois.png?v=1712758929&width=360 360w,//labelleboucle.fr/cdn/shop/files/Cutbyfred3mois.png?v=1712758929 500w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/Cutbyfred3mois.png?v=1712758929&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="500"
											height="500"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Compléments Alimentaires Vegan Hair Impulse
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
											
											
								

									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8516055925084"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_8516055925084"
										data-swaction="addToWishlist"
										data-product-id="8516055925084"
										data-variant-id="47963321434460"
										data-product-url="https://labelleboucle.fr/products/complements-alimentaires-vegan-hair-impulse"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-8516055925084">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8516055925084-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8516055925084-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8516055925084"
											data-product-url="/products/complements-alimentaires-vegan-hair-impulse"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-8516055925084" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Compléments Alimentaires Vegan Hair Impulse"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-8516055925084"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-8516055925084" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Cut By Fred </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8516055925084"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8516055925084"
								
							>
								Compléments Alimentaires Vegan Hair Impulse
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          32,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        32,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
										
										
							

								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8516055925084"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/complement-alimentaire-force-et-croissance"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8847054897500"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8847054897500 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8847054897500"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-forceetcroissance.png?v=1713796266&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-forceetcroissance.png?v=1713796266&width=165 165w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-forceetcroissance.png?v=1713796266&width=360 360w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-forceetcroissance.png?v=1713796266&width=533 533w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-forceetcroissance.png?v=1713796266 700w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Complément Alimentaire Force et Croissance"
										class="motion-reduce"
										
										width="700"
										height="700"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-cheveuxblancs_1.png?v=1713796301&width=165 165w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-cheveuxblancs_1.png?v=1713796301&width=360 360w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-cheveuxblancs_1.png?v=1713796301&width=533 533w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-cheveuxblancs_1.png?v=1713796301 700w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-cheveuxblancs_1.png?v=1713796301&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="700"
											height="700"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Complément Alimentaire Force et Croissance
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8847054897500"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_8847054897500"
										data-swaction="addToWishlist"
										data-product-id="8847054897500"
										data-variant-id="47974139232604"
										data-product-url="https://labelleboucle.fr/products/complement-alimentaire-force-et-croissance"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-8847054897500">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8847054897500-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8847054897500-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8847054897500"
											data-product-url="/products/complement-alimentaire-force-et-croissance"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-8847054897500" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Complément Alimentaire Force et Croissance"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-8847054897500"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-8847054897500" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Madame La Présidente </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8847054897500"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8847054897500"
								
							>
								Complément Alimentaire Force et Croissance
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          53,73€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        53,73€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              59,70€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8847054897500"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/complement-alimentaire-volume-et-densite"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8847047426396"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8847047426396 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8847047426396"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-volumeetdensite.png?v=1713794307&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-volumeetdensite.png?v=1713794307&width=165 165w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-volumeetdensite.png?v=1713794307&width=360 360w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-volumeetdensite.png?v=1713794307&width=533 533w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-volumeetdensite.png?v=1713794307 700w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Complément Alimentaire Volume et Densité"
										class="motion-reduce"
										
										width="700"
										height="700"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-volumeetdensite.png?v=1713794324&width=165 165w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-volumeetdensite.png?v=1713794324&width=360 360w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-volumeetdensite.png?v=1713794324&width=533 533w,//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-volumeetdensite.png?v=1713794324 700w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/ComplementsAlimentaires-MLP-3mois-volumeetdensite.png?v=1713794324&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="700"
											height="700"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Complément Alimentaire Volume et Densité
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8847047426396"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
						</div>

						<!-- 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_8847047426396"
										data-swaction="addToWishlist"
										data-product-id="8847047426396"
										data-variant-id="47974172918108"
										data-product-url="https://labelleboucle.fr/products/complement-alimentaire-volume-et-densite"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-8847047426396">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8847047426396-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8847047426396-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8847047426396"
											data-product-url="/products/complement-alimentaire-volume-et-densite"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-8847047426396" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Complément Alimentaire Volume et Densité"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-8847047426396"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-8847047426396" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Madame La Présidente </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8847047426396"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8847047426396"
								
							>
								Complément Alimentaire Volume et Densité
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--on-sale price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          53,73€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        53,73€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              59,70€
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -10%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
												<span
													id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8847047426396"
													class="badge badge--bottom-left color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589"
												>-10% pour 3</span>
											
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/recharge-masque-vegan-hydratation-mask"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-14771220250972"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-14771220250972 Badge-template--23691076305244__ax_featured_collections_PkRgLX-14771220250972"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Recharge_Masque_CBF.png?v=1731944665&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Recharge_Masque_CBF.png?v=1731944665&width=165 165w,//labelleboucle.fr/cdn/shop/files/Recharge_Masque_CBF.png?v=1731944665&width=360 360w,//labelleboucle.fr/cdn/shop/files/Recharge_Masque_CBF.png?v=1731944665&width=533 533w,//labelleboucle.fr/cdn/shop/files/Recharge_Masque_CBF.png?v=1731944665&width=720 720w,//labelleboucle.fr/cdn/shop/files/Recharge_Masque_CBF.png?v=1731944665&width=940 940w,//labelleboucle.fr/cdn/shop/files/Recharge_Masque_CBF.png?v=1731944665&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/Recharge_Masque_CBF.png?v=1731944665 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Recharge Masque Vegan Hydratation Mask"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Recharge Masque Vegan Hydratation Mask
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-14771220250972"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_14771220250972"
										data-swaction="addToWishlist"
										data-product-id="14771220250972"
										data-variant-id="53472979091804"
										data-product-url="https://labelleboucle.fr/products/recharge-masque-vegan-hydratation-mask"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX14771220250972" 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"
												value="53472979091804"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX14771220250972-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX14771220250972-submit title-template--23691076305244__ax_featured_collections_PkRgLX-14771220250972"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="14771220250972" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Cut By Fred </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="14771220250972"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-14771220250972"
								
							>
								Recharge Masque Vegan Hydratation Mask
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Format économique
											</div>
										
											<div class="card__resume">
												Hydrate en profondeur
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          46,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        46,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-14771220250972"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/mousse-cloud-fusion"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9599631917404"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9599631917404 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9599631917404"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/MousseCloudFusion.png?v=1728044057&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/MousseCloudFusion.png?v=1728044057&width=165 165w,//labelleboucle.fr/cdn/shop/files/MousseCloudFusion.png?v=1728044057&width=360 360w,//labelleboucle.fr/cdn/shop/files/MousseCloudFusion.png?v=1728044057&width=533 533w,//labelleboucle.fr/cdn/shop/files/MousseCloudFusion.png?v=1728044057&width=720 720w,//labelleboucle.fr/cdn/shop/files/MousseCloudFusion.png?v=1728044057&width=940 940w,//labelleboucle.fr/cdn/shop/files/MousseCloudFusion.png?v=1728044057&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/MousseCloudFusion.png?v=1728044057 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Mousse Coiffante Cloud Fusion"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Mousse Coiffante Cloud Fusion
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
											
											
								

									
										
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599631917404"
												class="badge badge--bottom-left color-new"
											>Coup de coeur</span>
											
</div>
						</div>

						<!-- 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_9599631917404"
										data-swaction="addToWishlist"
										data-product-id="9599631917404"
										data-variant-id="49413243470172"
										data-product-url="https://labelleboucle.fr/products/mousse-cloud-fusion"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599631917404" 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"
												value="49413243470172"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599631917404-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599631917404-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9599631917404"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9599631917404" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9599631917404"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9599631917404"
								
							>
								Mousse Coiffante Cloud Fusion
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Forme et gaine les boucles
											</div>
										
											<div class="card__resume">
												Apporte du volume
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          21,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        21,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
										
										
							

								
									
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599631917404"
											class="badge badge--bottom-left color-new"
										>Coup de coeur</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/masque-hyalu-fusion-mask"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9599621955932"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9599621955932 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9599621955932"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/MasqueHyaluFusion.png?v=1728044038&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/MasqueHyaluFusion.png?v=1728044038&width=165 165w,//labelleboucle.fr/cdn/shop/files/MasqueHyaluFusion.png?v=1728044038&width=360 360w,//labelleboucle.fr/cdn/shop/files/MasqueHyaluFusion.png?v=1728044038&width=533 533w,//labelleboucle.fr/cdn/shop/files/MasqueHyaluFusion.png?v=1728044038&width=720 720w,//labelleboucle.fr/cdn/shop/files/MasqueHyaluFusion.png?v=1728044038&width=940 940w,//labelleboucle.fr/cdn/shop/files/MasqueHyaluFusion.png?v=1728044038&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/MasqueHyaluFusion.png?v=1728044038 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Masque Hyalu Fusion Mask"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Masque Hyalu Fusion Mask
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599621955932"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9599621955932"
										data-swaction="addToWishlist"
										data-product-id="9599621955932"
										data-variant-id="49413218206044"
										data-product-url="https://labelleboucle.fr/products/masque-hyalu-fusion-mask"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599621955932" 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"
												value="49413218206044"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599621955932-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599621955932-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9599621955932"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9599621955932" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9599621955932"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9599621955932"
								
							>
								Masque Hyalu Fusion Mask
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Hydrate
											</div>
										
											<div class="card__resume">
												Dynamise les boucles
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          26,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        26,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599621955932"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/shampoing-care-fusion"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9599621333340"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9599621333340 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9599621333340"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/ShampoingCareFusion.png?v=1728044021&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/ShampoingCareFusion.png?v=1728044021&width=165 165w,//labelleboucle.fr/cdn/shop/files/ShampoingCareFusion.png?v=1728044021&width=360 360w,//labelleboucle.fr/cdn/shop/files/ShampoingCareFusion.png?v=1728044021&width=533 533w,//labelleboucle.fr/cdn/shop/files/ShampoingCareFusion.png?v=1728044021&width=720 720w,//labelleboucle.fr/cdn/shop/files/ShampoingCareFusion.png?v=1728044021&width=940 940w,//labelleboucle.fr/cdn/shop/files/ShampoingCareFusion.png?v=1728044021&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/ShampoingCareFusion.png?v=1728044021 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Shampoing Co-Wash Care Fusion"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Shampoing Co-Wash Care Fusion
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599621333340"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9599621333340"
										data-swaction="addToWishlist"
										data-product-id="9599621333340"
										data-variant-id="49413217419612"
										data-product-url="https://labelleboucle.fr/products/shampoing-care-fusion"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599621333340" 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"
												value="49413217419612"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599621333340-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599621333340-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9599621333340"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9599621333340" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9599621333340"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9599621333340"
								
							>
								Shampoing Co-Wash Care Fusion
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Nettoie en douceur
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          17,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        17,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599621333340"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/shampoing-regenerant"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9616808345948"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9616808345948 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9616808345948"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/ShampoingRegenerantLAO.png?v=1729754811&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/ShampoingRegenerantLAO.png?v=1729754811&width=165 165w,//labelleboucle.fr/cdn/shop/files/ShampoingRegenerantLAO.png?v=1729754811&width=360 360w,//labelleboucle.fr/cdn/shop/files/ShampoingRegenerantLAO.png?v=1729754811&width=533 533w,//labelleboucle.fr/cdn/shop/files/ShampoingRegenerantLAO.png?v=1729754811&width=720 720w,//labelleboucle.fr/cdn/shop/files/ShampoingRegenerantLAO.png?v=1729754811&width=940 940w,//labelleboucle.fr/cdn/shop/files/ShampoingRegenerantLAO.png?v=1729754811&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/ShampoingRegenerantLAO.png?v=1729754811 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Shampoing Régénérant Intense Protein Bonding"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Shampoing Régénérant Intense Protein Bonding
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9616808345948"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9616808345948"
										data-swaction="addToWishlist"
										data-product-id="9616808345948"
										data-variant-id="49462513697116"
										data-product-url="https://labelleboucle.fr/products/shampoing-regenerant"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616808345948" 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"
												value="49462513697116"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616808345948-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616808345948-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9616808345948"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9616808345948" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Lao Care </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9616808345948"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9616808345948"
								
							>
								Shampoing Régénérant Intense Protein Bonding
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Nettoie en douceur
											</div>
										
											<div class="card__resume">
												Apaise
											</div>
										
											<div class="card__resume">
												Régule l'excès de sébum
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          29,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        29,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9616808345948"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/masque-regenerant"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9616811295068"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9616811295068 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9616811295068"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/MasqueRegenerantLAO.png?v=1729755947&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/MasqueRegenerantLAO.png?v=1729755947&width=165 165w,//labelleboucle.fr/cdn/shop/files/MasqueRegenerantLAO.png?v=1729755947&width=360 360w,//labelleboucle.fr/cdn/shop/files/MasqueRegenerantLAO.png?v=1729755947&width=533 533w,//labelleboucle.fr/cdn/shop/files/MasqueRegenerantLAO.png?v=1729755947&width=720 720w,//labelleboucle.fr/cdn/shop/files/MasqueRegenerantLAO.png?v=1729755947&width=940 940w,//labelleboucle.fr/cdn/shop/files/MasqueRegenerantLAO.png?v=1729755947&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/MasqueRegenerantLAO.png?v=1729755947 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Masque Régénérant Intense Protein Bonding"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Masque Régénérant Intense Protein Bonding
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9616811295068"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9616811295068"
										data-swaction="addToWishlist"
										data-product-id="9616811295068"
										data-variant-id="49462525395292"
										data-product-url="https://labelleboucle.fr/products/masque-regenerant"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616811295068" 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"
												value="49462525395292"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616811295068-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616811295068-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9616811295068"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9616811295068" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Lao Care </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9616811295068"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9616811295068"
								
							>
								Masque Régénérant Intense Protein Bonding
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Régénère les cheveux abimés
											</div>
										
											<div class="card__resume">
												Nourrit en profondeur
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          39,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        39,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9616811295068"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/creme-regenerante"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9616812835164"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9616812835164 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9616812835164"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/CremeRegenerantLAO.png?v=1729756741&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/CremeRegenerantLAO.png?v=1729756741&width=165 165w,//labelleboucle.fr/cdn/shop/files/CremeRegenerantLAO.png?v=1729756741&width=360 360w,//labelleboucle.fr/cdn/shop/files/CremeRegenerantLAO.png?v=1729756741&width=533 533w,//labelleboucle.fr/cdn/shop/files/CremeRegenerantLAO.png?v=1729756741&width=720 720w,//labelleboucle.fr/cdn/shop/files/CremeRegenerantLAO.png?v=1729756741&width=940 940w,//labelleboucle.fr/cdn/shop/files/CremeRegenerantLAO.png?v=1729756741&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/CremeRegenerantLAO.png?v=1729756741 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Crème Régénérante Intense Protein Bonding"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Crème Régénérante Intense Protein Bonding
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9616812835164"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9616812835164"
										data-swaction="addToWishlist"
										data-product-id="9616812835164"
										data-variant-id="49462530343260"
										data-product-url="https://labelleboucle.fr/products/creme-regenerante"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616812835164" 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"
												value="49462530343260"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616812835164-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9616812835164-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9616812835164"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9616812835164" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Lao Care </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9616812835164"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9616812835164"
								
							>
								Crème Régénérante Intense Protein Bonding
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Définit les boucles
											</div>
										
											<div class="card__resume">
												Soigne en profondeur
											</div>
										
											<div class="card__resume">
												Apporte des protéines
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          29,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        29,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9616812835164"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/masque-capillaire-embellisseur"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9599352504668"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9599352504668 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9599352504668"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/MasqueEmbellisseurWAAM.png?v=1728911592&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/MasqueEmbellisseurWAAM.png?v=1728911592&width=165 165w,//labelleboucle.fr/cdn/shop/files/MasqueEmbellisseurWAAM.png?v=1728911592&width=360 360w,//labelleboucle.fr/cdn/shop/files/MasqueEmbellisseurWAAM.png?v=1728911592&width=533 533w,//labelleboucle.fr/cdn/shop/files/MasqueEmbellisseurWAAM.png?v=1728911592&width=720 720w,//labelleboucle.fr/cdn/shop/files/MasqueEmbellisseurWAAM.png?v=1728911592&width=940 940w,//labelleboucle.fr/cdn/shop/files/MasqueEmbellisseurWAAM.png?v=1728911592&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/MasqueEmbellisseurWAAM.png?v=1728911592 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Masque Capillaire Embellisseur"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Masque Capillaire Embellisseur
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599352504668"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9599352504668"
										data-swaction="addToWishlist"
										data-product-id="9599352504668"
										data-variant-id="49412251025756"
										data-product-url="https://labelleboucle.fr/products/masque-capillaire-embellisseur"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599352504668" 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"
												value="49412251025756"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599352504668-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599352504668-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9599352504668"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9599352504668" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Waam </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9599352504668"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9599352504668"
								
							>
								Masque Capillaire Embellisseur
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Nourrit
											</div>
										
											<div class="card__resume">
												Facilite le démêlage
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          17,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        17,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599352504668"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/gelee-capillaire-boucles"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9599353586012"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9599353586012 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9599353586012"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/GeleeCapillaireBoucles.png?v=1728982312&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/GeleeCapillaireBoucles.png?v=1728982312&width=165 165w,//labelleboucle.fr/cdn/shop/files/GeleeCapillaireBoucles.png?v=1728982312&width=360 360w,//labelleboucle.fr/cdn/shop/files/GeleeCapillaireBoucles.png?v=1728982312&width=533 533w,//labelleboucle.fr/cdn/shop/files/GeleeCapillaireBoucles.png?v=1728982312&width=720 720w,//labelleboucle.fr/cdn/shop/files/GeleeCapillaireBoucles.png?v=1728982312&width=940 940w,//labelleboucle.fr/cdn/shop/files/GeleeCapillaireBoucles.png?v=1728982312&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/GeleeCapillaireBoucles.png?v=1728982312 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Gelée Capillaire Boucles"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Gelée Capillaire Boucles
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599353586012"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9599353586012"
										data-swaction="addToWishlist"
										data-product-id="9599353586012"
										data-variant-id="49412255187292"
										data-product-url="https://labelleboucle.fr/products/gelee-capillaire-boucles"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599353586012" 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"
												value="49412255187292"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599353586012-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599353586012-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9599353586012"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9599353586012" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Waam </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9599353586012"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9599353586012"
								
							>
								Gelée Capillaire Boucles
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Gaine les boucles
											</div>
										
											<div class="card__resume">
												Hydrate
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          16,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        16,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599353586012"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/apres-shampoing-lao"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9599436980572"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9599436980572 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9599436980572"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Apres-ShampoingLAO.png?v=1727095781&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Apres-ShampoingLAO.png?v=1727095781&width=165 165w,//labelleboucle.fr/cdn/shop/files/Apres-ShampoingLAO.png?v=1727095781&width=360 360w,//labelleboucle.fr/cdn/shop/files/Apres-ShampoingLAO.png?v=1727095781&width=533 533w,//labelleboucle.fr/cdn/shop/files/Apres-ShampoingLAO.png?v=1727095781&width=720 720w,//labelleboucle.fr/cdn/shop/files/Apres-ShampoingLAO.png?v=1727095781&width=940 940w,//labelleboucle.fr/cdn/shop/files/Apres-ShampoingLAO.png?v=1727095781&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/Apres-ShampoingLAO.png?v=1727095781 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Après-Shampoing Chanvre et Olive"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Après-Shampoing Chanvre et Olive
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599436980572"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9599436980572"
										data-swaction="addToWishlist"
										data-product-id="9599436980572"
										data-variant-id="49412666982748"
										data-product-url="https://labelleboucle.fr/products/apres-shampoing-lao"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599436980572" 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"
												value="49412666982748"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599436980572-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9599436980572-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9599436980572"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9599436980572" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Lao Care </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9599436980572"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9599436980572"
								
							>
								Après-Shampoing Chanvre et Olive
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Démêle
											</div>
										
											<div class="card__resume">
												Protège
											</div>
										
											<div class="card__resume">
												Adoucit
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          24,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        24,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9599436980572"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/shampoing-solide-violet"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9605258183004"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9605258183004 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9605258183004"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/ShampoingSolideViolet.png?v=1729583694&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/ShampoingSolideViolet.png?v=1729583694&width=165 165w,//labelleboucle.fr/cdn/shop/files/ShampoingSolideViolet.png?v=1729583694&width=360 360w,//labelleboucle.fr/cdn/shop/files/ShampoingSolideViolet.png?v=1729583694&width=533 533w,//labelleboucle.fr/cdn/shop/files/ShampoingSolideViolet.png?v=1729583694&width=720 720w,//labelleboucle.fr/cdn/shop/files/ShampoingSolideViolet.png?v=1729583694&width=940 940w,//labelleboucle.fr/cdn/shop/files/ShampoingSolideViolet.png?v=1729583694&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/ShampoingSolideViolet.png?v=1729583694 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Shampoing Solide Violet"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Shampoing Solide Violet
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9605258183004"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9605258183004"
										data-swaction="addToWishlist"
										data-product-id="9605258183004"
										data-variant-id="49431489904988"
										data-product-url="https://labelleboucle.fr/products/shampoing-solide-violet"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9605258183004" 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"
												value="49431489904988"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9605258183004-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9605258183004-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9605258183004"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9605258183004" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Umaï </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9605258183004"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9605258183004"
								
							>
								Shampoing Solide Violet
							</h3>

							
								
									<div class="card__resumes">
										
											<div class="card__resume">
												Nettoie
											</div>
										
											<div class="card__resume">
												Déjaunit
											</div>
										
											<div class="card__resume">
												Illumine
											</div>
										
									</div>
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          19,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        19,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9605258183004"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/serviette-microfibre-anti-frisottis"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-9453555056988"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-9453555056988 Badge-template--23691076305244__ax_featured_collections_PkRgLX-9453555056988"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_1.png?v=1726827516&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_1.png?v=1726827516&width=165 165w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_1.png?v=1726827516&width=360 360w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_1.png?v=1726827516&width=533 533w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_1.png?v=1726827516&width=720 720w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_1.png?v=1726827516&width=940 940w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_1.png?v=1726827516&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_1.png?v=1726827516 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Serviette Microfibre Anti-Frisottis"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_2.png?v=1726827515&width=165 165w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_2.png?v=1726827515&width=360 360w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_2.png?v=1726827515&width=533 533w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_2.png?v=1726827515&width=720 720w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_2.png?v=1726827515&width=940 940w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_2.png?v=1726827515&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_2.png?v=1726827515 2000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/ServietteMicrofibreAnti-Frisottis_2.png?v=1726827515&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="2000"
											height="2000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Serviette Microfibre Anti-Frisottis
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9453555056988"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_9453555056988"
										data-swaction="addToWishlist"
										data-product-id="9453555056988"
										data-variant-id="48960500466012"
										data-product-url="https://labelleboucle.fr/products/serviette-microfibre-anti-frisottis"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9453555056988" 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"
												value="48960500466012"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9453555056988-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX9453555056988-submit title-template--23691076305244__ax_featured_collections_PkRgLX-9453555056988"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="9453555056988" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="9453555056988"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-9453555056988"
								
							>
								Serviette Microfibre Anti-Frisottis
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          20,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        20,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-9453555056988"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/livre-decomplexee-de-la-boucle"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8830941462876"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8830941462876 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8830941462876"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Livrerecto_b35ba661-19f0-48d4-9386-da3a5b4e85c6.png?v=1725286715&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Livrerecto_b35ba661-19f0-48d4-9386-da3a5b4e85c6.png?v=1725286715&width=165 165w,//labelleboucle.fr/cdn/shop/files/Livrerecto_b35ba661-19f0-48d4-9386-da3a5b4e85c6.png?v=1725286715&width=360 360w,//labelleboucle.fr/cdn/shop/files/Livrerecto_b35ba661-19f0-48d4-9386-da3a5b4e85c6.png?v=1725286715&width=533 533w,//labelleboucle.fr/cdn/shop/files/Livrerecto_b35ba661-19f0-48d4-9386-da3a5b4e85c6.png?v=1725286715 700w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Livre “Décomplexée de la Boucle” - Le guide des cheveux bouclés"
										class="motion-reduce"
										
										width="700"
										height="700"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/Livreverso.png?v=1724767541&width=165 165w,//labelleboucle.fr/cdn/shop/files/Livreverso.png?v=1724767541&width=360 360w,//labelleboucle.fr/cdn/shop/files/Livreverso.png?v=1724767541&width=533 533w,//labelleboucle.fr/cdn/shop/files/Livreverso.png?v=1724767541 700w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/Livreverso.png?v=1724767541&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="700"
											height="700"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Livre “Décomplexée de la Boucle” - Le guide des cheveux bouclés
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8830941462876"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_8830941462876"
										data-swaction="addToWishlist"
										data-product-id="8830941462876"
										data-variant-id="47921629200732"
										data-product-url="https://labelleboucle.fr/products/livre-decomplexee-de-la-boucle"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8830941462876" 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"
												value="47921629200732"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8830941462876-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8830941462876-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8830941462876"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="8830941462876" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8830941462876"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8830941462876"
								
							>
								Livre “Décomplexée de la Boucle” - Le guide des cheveux bouclés
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          19,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        19,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8830941462876"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/taie-d-oreiller-en-satin"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8681485762908"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8681485762908 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8681485762908"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Taie_Rose_6ed9c018-eb00-427b-b38e-051cddf2bd97.png?v=1726048765&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Taie_Rose_6ed9c018-eb00-427b-b38e-051cddf2bd97.png?v=1726048765&width=165 165w,//labelleboucle.fr/cdn/shop/files/Taie_Rose_6ed9c018-eb00-427b-b38e-051cddf2bd97.png?v=1726048765&width=360 360w,//labelleboucle.fr/cdn/shop/files/Taie_Rose_6ed9c018-eb00-427b-b38e-051cddf2bd97.png?v=1726048765&width=533 533w,//labelleboucle.fr/cdn/shop/files/Taie_Rose_6ed9c018-eb00-427b-b38e-051cddf2bd97.png?v=1726048765 700w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Taie d&#39;Oreiller en Satin"
										class="motion-reduce"
										
										width="700"
										height="700"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/2_Taies_Rose_a6ee7ef1-2675-4acc-a6ef-2483ac289fdf.png?v=1726048775&width=165 165w,//labelleboucle.fr/cdn/shop/files/2_Taies_Rose_a6ee7ef1-2675-4acc-a6ef-2483ac289fdf.png?v=1726048775&width=360 360w,//labelleboucle.fr/cdn/shop/files/2_Taies_Rose_a6ee7ef1-2675-4acc-a6ef-2483ac289fdf.png?v=1726048775&width=533 533w,//labelleboucle.fr/cdn/shop/files/2_Taies_Rose_a6ee7ef1-2675-4acc-a6ef-2483ac289fdf.png?v=1726048775 700w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/2_Taies_Rose_a6ee7ef1-2675-4acc-a6ef-2483ac289fdf.png?v=1726048775&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="700"
											height="700"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Taie d&#39;Oreiller en Satin
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
											
											
								

									
										
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8681485762908"
												class="badge badge--bottom-left color-new"
											>Coup de coeur</span>
											
</div>
						</div>

						<!-- 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_8681485762908"
										data-swaction="addToWishlist"
										data-product-id="8681485762908"
										data-variant-id="49348694573404"
										data-product-url="https://labelleboucle.fr/products/taie-d-oreiller-en-satin"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-8681485762908">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8681485762908-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8681485762908-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8681485762908"
											data-product-url="/products/taie-d-oreiller-en-satin"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-8681485762908" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Taie d&amp;#39;Oreiller en Satin"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-8681485762908"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-8681485762908" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8681485762908"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8681485762908"
								
							>
								Taie d&#39;Oreiller en Satin
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          39,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        39,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
										
										
							

								
									
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8681485762908"
											class="badge badge--bottom-left color-new"
										>Coup de coeur</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/shampoing-matcha-scrub"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8734071390556"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8734071390556 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8734071390556"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/ShampoingMatchaScrub.png?v=1710249249&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/ShampoingMatchaScrub.png?v=1710249249&width=165 165w,//labelleboucle.fr/cdn/shop/files/ShampoingMatchaScrub.png?v=1710249249&width=360 360w,//labelleboucle.fr/cdn/shop/files/ShampoingMatchaScrub.png?v=1710249249&width=533 533w,//labelleboucle.fr/cdn/shop/files/ShampoingMatchaScrub.png?v=1710249249&width=720 720w,//labelleboucle.fr/cdn/shop/files/ShampoingMatchaScrub.png?v=1710249249&width=940 940w,//labelleboucle.fr/cdn/shop/files/ShampoingMatchaScrub.png?v=1710249249 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Shampoing Matcha Scrub"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Shampoing Matcha Scrub
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
											
											
								

									
										
										
										
									
										
										
										
									
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8734071390556"
												class="badge badge--bottom-left color-new"
											>Nouveau</span>
											
</div>
						</div>

						<!-- 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_8734071390556"
										data-swaction="addToWishlist"
										data-product-id="8734071390556"
										data-variant-id="47608356897116"
										data-product-url="https://labelleboucle.fr/products/shampoing-matcha-scrub"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8734071390556" 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"
												value="47608356897116"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8734071390556-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8734071390556-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8734071390556"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="8734071390556" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Pomelo+Co </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8734071390556"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8734071390556"
								
							>
								Shampoing Matcha Scrub
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          14,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        14,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
										
										
							

								
									
									
									
								
									
									
									
								
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8734071390556"
											class="badge badge--bottom-left color-new"
										>Nouveau</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/soin-coiffant-creme-gel"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952634515526"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952634515526 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952634515526"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/CremeGelLaBelleBoucle.png?v=1674820309&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/CremeGelLaBelleBoucle.png?v=1674820309&width=165 165w,//labelleboucle.fr/cdn/shop/products/CremeGelLaBelleBoucle.png?v=1674820309&width=360 360w,//labelleboucle.fr/cdn/shop/products/CremeGelLaBelleBoucle.png?v=1674820309 500w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Soin Coiffant Crème Gel"
										class="motion-reduce"
										
										width="500"
										height="500"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/products/creme-gel-la-belle-boucle-texture.jpg?v=1674820309&width=165 165w,//labelleboucle.fr/cdn/shop/products/creme-gel-la-belle-boucle-texture.jpg?v=1674820309&width=360 360w,//labelleboucle.fr/cdn/shop/products/creme-gel-la-belle-boucle-texture.jpg?v=1674820309&width=533 533w,//labelleboucle.fr/cdn/shop/products/creme-gel-la-belle-boucle-texture.jpg?v=1674820309&width=720 720w,//labelleboucle.fr/cdn/shop/products/creme-gel-la-belle-boucle-texture.jpg?v=1674820309&width=940 940w,//labelleboucle.fr/cdn/shop/products/creme-gel-la-belle-boucle-texture.jpg?v=1674820309 1000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/products/creme-gel-la-belle-boucle-texture.jpg?v=1674820309&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="1000"
											height="1007"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Soin Coiffant Crème Gel
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_6952634515526"
										data-swaction="addToWishlist"
										data-product-id="6952634515526"
										data-variant-id="40167043760198"
										data-product-url="https://labelleboucle.fr/products/soin-coiffant-creme-gel"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952634515526" 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"
												value="40167043760198"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952634515526-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952634515526-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952634515526"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6952634515526" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952634515526"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952634515526"
								
							>
								Soin Coiffant Crème Gel
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          29,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        29,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/gelee-capillaire-boost-curl"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6946848571462"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6946848571462 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6946848571462"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/Boost-Curl-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087492&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/Boost-Curl-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087492&width=165 165w,//labelleboucle.fr/cdn/shop/products/Boost-Curl-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087492&width=360 360w,//labelleboucle.fr/cdn/shop/products/Boost-Curl-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087492&width=533 533w,//labelleboucle.fr/cdn/shop/products/Boost-Curl-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087492&width=720 720w,//labelleboucle.fr/cdn/shop/products/Boost-Curl-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087492&width=940 940w,//labelleboucle.fr/cdn/shop/products/Boost-Curl-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087492 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Gelée Capillaire Boost Curl"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Gelée Capillaire Boost Curl
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_6946848571462"
										data-swaction="addToWishlist"
										data-product-id="6946848571462"
										data-variant-id="40152677875782"
										data-product-url="https://labelleboucle.fr/products/gelee-capillaire-boost-curl"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848571462" 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"
												value="40152677875782"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848571462-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848571462-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6946848571462"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6946848571462" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6946848571462"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6946848571462"
								
							>
								Gelée Capillaire Boost Curl
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          19,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        19,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/masque-vegan-hydratation-mask"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6990886568006"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6990886568006 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6990886568006"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Masque-CBF_07ed2572-4976-4e1e-a4c6-ef5eb7bc596a.png?v=1732178337&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Masque-CBF_07ed2572-4976-4e1e-a4c6-ef5eb7bc596a.png?v=1732178337&width=165 165w,//labelleboucle.fr/cdn/shop/files/Masque-CBF_07ed2572-4976-4e1e-a4c6-ef5eb7bc596a.png?v=1732178337&width=360 360w,//labelleboucle.fr/cdn/shop/files/Masque-CBF_07ed2572-4976-4e1e-a4c6-ef5eb7bc596a.png?v=1732178337&width=533 533w,//labelleboucle.fr/cdn/shop/files/Masque-CBF_07ed2572-4976-4e1e-a4c6-ef5eb7bc596a.png?v=1732178337&width=720 720w,//labelleboucle.fr/cdn/shop/files/Masque-CBF_07ed2572-4976-4e1e-a4c6-ef5eb7bc596a.png?v=1732178337&width=940 940w,//labelleboucle.fr/cdn/shop/files/Masque-CBF_07ed2572-4976-4e1e-a4c6-ef5eb7bc596a.png?v=1732178337 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Masque Vegan Hydratation Mask"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Masque Vegan Hydratation Mask
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6990886568006"
												class="badge badge--bottom-left color-new"
											>Coup de coeur</span>
											
</div>
						</div>

						<!-- 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_6990886568006"
										data-swaction="addToWishlist"
										data-product-id="6990886568006"
										data-variant-id="53492557840732"
										data-product-url="https://labelleboucle.fr/products/masque-vegan-hydratation-mask"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6990886568006" 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"
												value="53492557840732"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6990886568006-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6990886568006-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6990886568006"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6990886568006" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Cut By Fred </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6990886568006"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6990886568006"
								
							>
								Masque Vegan Hydratation Mask
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          36,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        36,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-6990886568006"
											class="badge badge--bottom-left color-new"
										>Coup de coeur</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/soin-multi-usages-gel-aloe-vera"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-7093426716742"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-7093426716742 Badge-template--23691076305244__ax_featured_collections_PkRgLX-7093426716742"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/SOINgelaloeveraLaBelleBoucle11.26.48.png?v=1680598054&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/SOINgelaloeveraLaBelleBoucle11.26.48.png?v=1680598054&width=165 165w,//labelleboucle.fr/cdn/shop/products/SOINgelaloeveraLaBelleBoucle11.26.48.png?v=1680598054&width=360 360w,//labelleboucle.fr/cdn/shop/products/SOINgelaloeveraLaBelleBoucle11.26.48.png?v=1680598054&width=533 533w,//labelleboucle.fr/cdn/shop/products/SOINgelaloeveraLaBelleBoucle11.26.48.png?v=1680598054&width=720 720w,//labelleboucle.fr/cdn/shop/products/SOINgelaloeveraLaBelleBoucle11.26.48.png?v=1680598054&width=940 940w,//labelleboucle.fr/cdn/shop/products/SOINgelaloeveraLaBelleBoucle11.26.48.png?v=1680598054 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Soin Multi-Usages Gel Aloe Vera"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/products/AloeveraLaBelleBoucle1.png?v=1680598053&width=165 165w,//labelleboucle.fr/cdn/shop/products/AloeveraLaBelleBoucle1.png?v=1680598053&width=360 360w,//labelleboucle.fr/cdn/shop/products/AloeveraLaBelleBoucle1.png?v=1680598053&width=533 533w,//labelleboucle.fr/cdn/shop/products/AloeveraLaBelleBoucle1.png?v=1680598053&width=720 720w,//labelleboucle.fr/cdn/shop/products/AloeveraLaBelleBoucle1.png?v=1680598053&width=940 940w,//labelleboucle.fr/cdn/shop/products/AloeveraLaBelleBoucle1.png?v=1680598053 1000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/products/AloeveraLaBelleBoucle1.png?v=1680598053&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="1000"
											height="1000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Soin Multi-Usages Gel Aloe Vera
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-7093426716742"
												class="badge badge--bottom-left color-new"
											>Coup de coeur</span>
											
</div>
						</div>

						<!-- 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_7093426716742"
										data-swaction="addToWishlist"
										data-product-id="7093426716742"
										data-variant-id="40513540227142"
										data-product-url="https://labelleboucle.fr/products/soin-multi-usages-gel-aloe-vera"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX7093426716742" 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"
												value="40513540227142"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX7093426716742-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX7093426716742-submit title-template--23691076305244__ax_featured_collections_PkRgLX-7093426716742"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="7093426716742" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="7093426716742"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-7093426716742"
								
							>
								Soin Multi-Usages Gel Aloe Vera
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          14,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        14,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-7093426716742"
											class="badge badge--bottom-left color-new"
										>Coup de coeur</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/creme-capillaire-kurl-nectar"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6946848407622"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6946848407622 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6946848407622"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/Les-Secrets-de-Loly-Kurl-Nectar-La-Belle-Boucle.png?v=1656087487&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/Les-Secrets-de-Loly-Kurl-Nectar-La-Belle-Boucle.png?v=1656087487&width=165 165w,//labelleboucle.fr/cdn/shop/products/Les-Secrets-de-Loly-Kurl-Nectar-La-Belle-Boucle.png?v=1656087487&width=360 360w,//labelleboucle.fr/cdn/shop/products/Les-Secrets-de-Loly-Kurl-Nectar-La-Belle-Boucle.png?v=1656087487&width=533 533w,//labelleboucle.fr/cdn/shop/products/Les-Secrets-de-Loly-Kurl-Nectar-La-Belle-Boucle.png?v=1656087487&width=720 720w,//labelleboucle.fr/cdn/shop/products/Les-Secrets-de-Loly-Kurl-Nectar-La-Belle-Boucle.png?v=1656087487&width=940 940w,//labelleboucle.fr/cdn/shop/products/Les-Secrets-de-Loly-Kurl-Nectar-La-Belle-Boucle.png?v=1656087487 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Crème Capillaire Kurl Nectar"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Crème Capillaire Kurl Nectar
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_6946848407622"
										data-swaction="addToWishlist"
										data-product-id="6946848407622"
										data-variant-id="40152677744710"
										data-product-url="https://labelleboucle.fr/products/creme-capillaire-kurl-nectar"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848407622" 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"
												value="40152677744710"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848407622-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848407622-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6946848407622"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6946848407622" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6946848407622"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6946848407622"
								
							>
								Crème Capillaire Kurl Nectar
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          20,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        20,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/soin-anti-frisottis-brume-capillaire"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8490894328156"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8490894328156 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8490894328156"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/BrumeCapillaireAnti-FrisottisLaBelleBoucle.png?v=1695988632&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/BrumeCapillaireAnti-FrisottisLaBelleBoucle.png?v=1695988632&width=165 165w,//labelleboucle.fr/cdn/shop/files/BrumeCapillaireAnti-FrisottisLaBelleBoucle.png?v=1695988632&width=360 360w,//labelleboucle.fr/cdn/shop/files/BrumeCapillaireAnti-FrisottisLaBelleBoucle.png?v=1695988632 500w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Soin Anti-Frisottis Brume Capillaire"
										class="motion-reduce"
										
										width="500"
										height="500"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/Fichesproduits_4.png?v=1698221681&width=165 165w,//labelleboucle.fr/cdn/shop/files/Fichesproduits_4.png?v=1698221681&width=360 360w,//labelleboucle.fr/cdn/shop/files/Fichesproduits_4.png?v=1698221681 500w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/Fichesproduits_4.png?v=1698221681&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="500"
											height="500"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Soin Anti-Frisottis Brume Capillaire
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_8490894328156"
										data-swaction="addToWishlist"
										data-product-id="8490894328156"
										data-variant-id="46957764706652"
										data-product-url="https://labelleboucle.fr/products/soin-anti-frisottis-brume-capillaire"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8490894328156" 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"
												value="46957764706652"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8490894328156-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8490894328156-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8490894328156"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="8490894328156" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8490894328156"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8490894328156"
								
							>
								Soin Anti-Frisottis Brume Capillaire
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          17,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        17,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/vaporisateur-cheveux-boucles"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952623505478"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952623505478 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952623505478"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Vaporisateur_74423565-11b7-42ad-82f9-03a47be4b4b0.png?v=1723100810&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Vaporisateur_74423565-11b7-42ad-82f9-03a47be4b4b0.png?v=1723100810&width=165 165w,//labelleboucle.fr/cdn/shop/files/Vaporisateur_74423565-11b7-42ad-82f9-03a47be4b4b0.png?v=1723100810&width=360 360w,//labelleboucle.fr/cdn/shop/files/Vaporisateur_74423565-11b7-42ad-82f9-03a47be4b4b0.png?v=1723100810&width=533 533w,//labelleboucle.fr/cdn/shop/files/Vaporisateur_74423565-11b7-42ad-82f9-03a47be4b4b0.png?v=1723100810 700w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Vaporisateur Cheveux Bouclés"
										class="motion-reduce"
										
										width="700"
										height="700"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/vapo-lbb_1a539402-78eb-4e70-89a8-fd14e4d38f83.png?v=1723100802&width=165 165w,//labelleboucle.fr/cdn/shop/files/vapo-lbb_1a539402-78eb-4e70-89a8-fd14e4d38f83.png?v=1723100802&width=360 360w,//labelleboucle.fr/cdn/shop/files/vapo-lbb_1a539402-78eb-4e70-89a8-fd14e4d38f83.png?v=1723100802&width=533 533w,//labelleboucle.fr/cdn/shop/files/vapo-lbb_1a539402-78eb-4e70-89a8-fd14e4d38f83.png?v=1723100802&width=720 720w,//labelleboucle.fr/cdn/shop/files/vapo-lbb_1a539402-78eb-4e70-89a8-fd14e4d38f83.png?v=1723100802&width=940 940w,//labelleboucle.fr/cdn/shop/files/vapo-lbb_1a539402-78eb-4e70-89a8-fd14e4d38f83.png?v=1723100802 1000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/vapo-lbb_1a539402-78eb-4e70-89a8-fd14e4d38f83.png?v=1723100802&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="1000"
											height="1000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Vaporisateur Cheveux Bouclés
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
								
</div>
						</div>

						<!-- 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_6952623505478"
										data-swaction="addToWishlist"
										data-product-id="6952623505478"
										data-variant-id="49168371712348"
										data-product-url="https://labelleboucle.fr/products/vaporisateur-cheveux-boucles"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><modal-opener data-modal="#QuickAdd-6952623505478">
										<button
											id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952623505478-submit"
											type="submit"
											name="add"
											class="quick-add__submit button button--full-width button--secondary"
											aria-haspopup="dialog"
											aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952623505478-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952623505478"
											data-product-url="/products/vaporisateur-cheveux-boucles"
										>
											<svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg>



<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>
									</modal-opener>
									<quick-add-modal id="QuickAdd-6952623505478" class="quick-add-modal">
										<div
											role="dialog"
											aria-label="Choisir des options pour Vaporisateur Cheveux Bouclés"
											aria-modal="true"
											class="quick-add-modal__content global-settings-popup"
											tabindex="-1"
										>
											<button
												id="ModalClose-6952623505478"
												type="button"
												class="quick-add-modal__toggle"
												aria-label="Fermer"
											>
												<svg
  xmlns="http://www.w3.org/2000/svg"
  aria-hidden="true"
  focusable="false"
  class="icon icon-close"
  fill="none"
  viewBox="0 0 18 17"
>
  <path d="M.865 15.978a.5.5 0 00.707.707l7.433-7.431 7.579 7.282a.501.501 0 00.846-.37.5.5 0 00-.153-.351L9.712 8.546l7.417-7.416a.5.5 0 10-.707-.708L8.991 7.853 1.413.573a.5.5 0 10-.693.72l7.563 7.268-7.418 7.417z" fill="currentColor">
</svg>

											</button>
											<div id="QuickAddInfo-6952623505478" class="quick-add-modal__content-info"></div>
										</div>
									</quick-add-modal></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952623505478"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952623505478"
								
							>
								Vaporisateur Cheveux Bouclés
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          10,50€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        10,50€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/soin-hydratant-masque-capillaire"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8659527139676"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8659527139676 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8659527139676"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/SoinhydratantLBB.png?v=1706171116&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/SoinhydratantLBB.png?v=1706171116&width=165 165w,//labelleboucle.fr/cdn/shop/files/SoinhydratantLBB.png?v=1706171116&width=360 360w,//labelleboucle.fr/cdn/shop/files/SoinhydratantLBB.png?v=1706171116&width=533 533w,//labelleboucle.fr/cdn/shop/files/SoinhydratantLBB.png?v=1706171116&width=720 720w,//labelleboucle.fr/cdn/shop/files/SoinhydratantLBB.png?v=1706171116&width=940 940w,//labelleboucle.fr/cdn/shop/files/SoinhydratantLBB.png?v=1706171116 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Soin Hydratant Masque Capillaire"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/Masque2LBB_2.png?v=1706171116&width=165 165w,//labelleboucle.fr/cdn/shop/files/Masque2LBB_2.png?v=1706171116&width=360 360w,//labelleboucle.fr/cdn/shop/files/Masque2LBB_2.png?v=1706171116&width=533 533w,//labelleboucle.fr/cdn/shop/files/Masque2LBB_2.png?v=1706171116&width=720 720w,//labelleboucle.fr/cdn/shop/files/Masque2LBB_2.png?v=1706171116&width=940 940w,//labelleboucle.fr/cdn/shop/files/Masque2LBB_2.png?v=1706171116&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/Masque2LBB_2.png?v=1706171116 3619w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/Masque2LBB_2.png?v=1706171116&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="3619"
											height="3619"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Soin Hydratant Masque Capillaire
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_8659527139676"
										data-swaction="addToWishlist"
										data-product-id="8659527139676"
										data-variant-id="49480763736412"
										data-product-url="https://labelleboucle.fr/products/soin-hydratant-masque-capillaire"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8659527139676" 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"
												value="49480763736412"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8659527139676-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8659527139676-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8659527139676"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="8659527139676" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8659527139676"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8659527139676"
								
							>
								Soin Hydratant Masque Capillaire
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          27,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        27,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/shampoing-purifiant-premiere-mousse"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952622817350"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952622817350 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952622817350"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/Shampoing-Premiere-Mousse-Noire-oo-naturel-La-Belle-Boucle.png?v=1656629677&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/Shampoing-Premiere-Mousse-Noire-oo-naturel-La-Belle-Boucle.png?v=1656629677&width=165 165w,//labelleboucle.fr/cdn/shop/products/Shampoing-Premiere-Mousse-Noire-oo-naturel-La-Belle-Boucle.png?v=1656629677&width=360 360w,//labelleboucle.fr/cdn/shop/products/Shampoing-Premiere-Mousse-Noire-oo-naturel-La-Belle-Boucle.png?v=1656629677&width=533 533w,//labelleboucle.fr/cdn/shop/products/Shampoing-Premiere-Mousse-Noire-oo-naturel-La-Belle-Boucle.png?v=1656629677&width=720 720w,//labelleboucle.fr/cdn/shop/products/Shampoing-Premiere-Mousse-Noire-oo-naturel-La-Belle-Boucle.png?v=1656629677&width=940 940w,//labelleboucle.fr/cdn/shop/products/Shampoing-Premiere-Mousse-Noire-oo-naturel-La-Belle-Boucle.png?v=1656629677 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Shampoing Purifiant Première Mousse"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Shampoing Purifiant Première Mousse
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_6952622817350"
										data-swaction="addToWishlist"
										data-product-id="6952622817350"
										data-variant-id="40167023050822"
										data-product-url="https://labelleboucle.fr/products/shampoing-purifiant-premiere-mousse"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952622817350" 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"
												value="40167023050822"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952622817350-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952622817350-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952622817350"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6952622817350" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Noireônaturel </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952622817350"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952622817350"
								
							>
								Shampoing Purifiant Première Mousse
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          13,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        13,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/creme-capillaire-boucles-souples-noix-de-coco"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952623636550"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952623636550 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952623636550"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/Creme-capillaire-coco-Desert-Essence-La-Belle-Boucle.png?v=1694071214&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/Creme-capillaire-coco-Desert-Essence-La-Belle-Boucle.png?v=1694071214&width=165 165w,//labelleboucle.fr/cdn/shop/products/Creme-capillaire-coco-Desert-Essence-La-Belle-Boucle.png?v=1694071214&width=360 360w,//labelleboucle.fr/cdn/shop/products/Creme-capillaire-coco-Desert-Essence-La-Belle-Boucle.png?v=1694071214&width=533 533w,//labelleboucle.fr/cdn/shop/products/Creme-capillaire-coco-Desert-Essence-La-Belle-Boucle.png?v=1694071214&width=720 720w,//labelleboucle.fr/cdn/shop/products/Creme-capillaire-coco-Desert-Essence-La-Belle-Boucle.png?v=1694071214&width=940 940w,//labelleboucle.fr/cdn/shop/products/Creme-capillaire-coco-Desert-Essence-La-Belle-Boucle.png?v=1694071214 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Crème Capillaire Boucles Souples Noix de Coco"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Crème Capillaire Boucles Souples Noix de Coco
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_6952623636550"
										data-swaction="addToWishlist"
										data-product-id="6952623636550"
										data-variant-id="40167023837254"
										data-product-url="https://labelleboucle.fr/products/creme-capillaire-boucles-souples-noix-de-coco"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952623636550" 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"
												value="40167023837254"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952623636550-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952623636550-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952623636550"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6952623636550" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Desert Essence </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952623636550"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952623636550"
								
							>
								Crème Capillaire Boucles Souples Noix de Coco
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          11,60€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        11,60€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/lot-de-3-elastiques-en-spirales"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6952624488518"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6952624488518 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6952624488518"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Elastiques-Spirales-par-3_c406de57-0a8e-4f79-a3e8-6399e09f78e7.png?v=1702983812&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Elastiques-Spirales-par-3_c406de57-0a8e-4f79-a3e8-6399e09f78e7.png?v=1702983812&width=165 165w,//labelleboucle.fr/cdn/shop/files/Elastiques-Spirales-par-3_c406de57-0a8e-4f79-a3e8-6399e09f78e7.png?v=1702983812&width=360 360w,//labelleboucle.fr/cdn/shop/files/Elastiques-Spirales-par-3_c406de57-0a8e-4f79-a3e8-6399e09f78e7.png?v=1702983812&width=533 533w,//labelleboucle.fr/cdn/shop/files/Elastiques-Spirales-par-3_c406de57-0a8e-4f79-a3e8-6399e09f78e7.png?v=1702983812 600w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Lot de 3 Élastiques en spirales"
										class="motion-reduce"
										
										width="600"
										height="600"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/elastique-spirale-belle-boucle_1_2f925222-8b94-427e-b0e5-c9ba8c8b7fb9.png?v=1702983918&width=165 165w,//labelleboucle.fr/cdn/shop/files/elastique-spirale-belle-boucle_1_2f925222-8b94-427e-b0e5-c9ba8c8b7fb9.png?v=1702983918&width=360 360w,//labelleboucle.fr/cdn/shop/files/elastique-spirale-belle-boucle_1_2f925222-8b94-427e-b0e5-c9ba8c8b7fb9.png?v=1702983918&width=533 533w,//labelleboucle.fr/cdn/shop/files/elastique-spirale-belle-boucle_1_2f925222-8b94-427e-b0e5-c9ba8c8b7fb9.png?v=1702983918&width=720 720w,//labelleboucle.fr/cdn/shop/files/elastique-spirale-belle-boucle_1_2f925222-8b94-427e-b0e5-c9ba8c8b7fb9.png?v=1702983918&width=940 940w,//labelleboucle.fr/cdn/shop/files/elastique-spirale-belle-boucle_1_2f925222-8b94-427e-b0e5-c9ba8c8b7fb9.png?v=1702983918 1000w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/elastique-spirale-belle-boucle_1_2f925222-8b94-427e-b0e5-c9ba8c8b7fb9.png?v=1702983918&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="1000"
											height="1000"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Lot de 3 Élastiques en spirales
								</div>
							</div>
							<div class="card__badge top left">
								
</div>
						</div>

						<!-- 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_6952624488518"
										data-swaction="addToWishlist"
										data-product-id="6952624488518"
										data-variant-id="40167025442886"
										data-product-url="https://labelleboucle.fr/products/lot-de-3-elastiques-en-spirales"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952624488518" 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"
												value="40167025442886"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952624488518-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6952624488518-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6952624488518"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6952624488518" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6952624488518"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6952624488518"
								
							>
								Lot de 3 Élastiques en spirales
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          2,90€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        2,90€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/apres-shampoing-pink-paradise"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6946848079942"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6946848079942 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6946848079942"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/Pink-Paradise-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087474&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/Pink-Paradise-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087474&width=165 165w,//labelleboucle.fr/cdn/shop/products/Pink-Paradise-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087474&width=360 360w,//labelleboucle.fr/cdn/shop/products/Pink-Paradise-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087474&width=533 533w,//labelleboucle.fr/cdn/shop/products/Pink-Paradise-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087474&width=720 720w,//labelleboucle.fr/cdn/shop/products/Pink-Paradise-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087474&width=940 940w,//labelleboucle.fr/cdn/shop/products/Pink-Paradise-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087474 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Après-Shampoing Pink Paradise"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Après-Shampoing Pink Paradise
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_6946848079942"
										data-swaction="addToWishlist"
										data-product-id="6946848079942"
										data-variant-id="40152675745862"
										data-product-url="https://labelleboucle.fr/products/apres-shampoing-pink-paradise"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848079942" 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"
												value="40152675745862"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848079942-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848079942-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6946848079942"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6946848079942" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6946848079942"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6946848079942"
								
							>
								Après-Shampoing Pink Paradise
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          16,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        16,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/shampoing-equilibrant"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-7083569053766"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-7083569053766 Badge-template--23691076305244__ax_featured_collections_PkRgLX-7083569053766"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Shampoing_Equilibrant.png?v=1730112485&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Shampoing_Equilibrant.png?v=1730112485&width=165 165w,//labelleboucle.fr/cdn/shop/files/Shampoing_Equilibrant.png?v=1730112485&width=360 360w,//labelleboucle.fr/cdn/shop/files/Shampoing_Equilibrant.png?v=1730112485&width=533 533w,//labelleboucle.fr/cdn/shop/files/Shampoing_Equilibrant.png?v=1730112485&width=720 720w,//labelleboucle.fr/cdn/shop/files/Shampoing_Equilibrant.png?v=1730112485&width=940 940w,//labelleboucle.fr/cdn/shop/files/Shampoing_Equilibrant.png?v=1730112485&width=1066 1066w,//labelleboucle.fr/cdn/shop/files/Shampoing_Equilibrant.png?v=1730112485 2000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Soin Purifiant Shampoing Équilibrant"
										class="motion-reduce"
										
										width="2000"
										height="2000"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/products/Shampoing_equilivrant_la_belle_boucle.png?v=1674820100&width=165 165w,//labelleboucle.fr/cdn/shop/products/Shampoing_equilivrant_la_belle_boucle.png?v=1674820100&width=360 360w,//labelleboucle.fr/cdn/shop/products/Shampoing_equilivrant_la_belle_boucle.png?v=1674820100 500w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/products/Shampoing_equilivrant_la_belle_boucle.png?v=1674820100&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="500"
											height="500"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Soin Purifiant Shampoing Équilibrant
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_7083569053766"
										data-swaction="addToWishlist"
										data-product-id="7083569053766"
										data-variant-id="40479432147014"
										data-product-url="https://labelleboucle.fr/products/shampoing-equilibrant"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX7083569053766" 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"
												value="40479432147014"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX7083569053766-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX7083569053766-submit title-template--23691076305244__ax_featured_collections_PkRgLX-7083569053766"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="7083569053766" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="7083569053766"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-7083569053766"
								
							>
								Soin Purifiant Shampoing Équilibrant
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          16,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        16,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product >
			<a
				href="/products/masque-hydratant-repair-time"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-6946848735302"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-6946848735302 Badge-template--23691076305244__ax_featured_collections_PkRgLX-6946848735302"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/products/Repair-time-masque-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087497&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/products/Repair-time-masque-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087497&width=165 165w,//labelleboucle.fr/cdn/shop/products/Repair-time-masque-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087497&width=360 360w,//labelleboucle.fr/cdn/shop/products/Repair-time-masque-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087497&width=533 533w,//labelleboucle.fr/cdn/shop/products/Repair-time-masque-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087497&width=720 720w,//labelleboucle.fr/cdn/shop/products/Repair-time-masque-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087497&width=940 940w,//labelleboucle.fr/cdn/shop/products/Repair-time-masque-Les-Secrets-de-Loly-La-Belle-Boucle.png?v=1656087497 1000w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Masque Hydratant Repair Time"
										class="motion-reduce"
										
										width="1000"
										height="1000"
									>
									
</div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Masque Hydratant Repair Time
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
									
								
</div>
						</div>

						<!-- 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_6946848735302"
										data-swaction="addToWishlist"
										data-product-id="6946848735302"
										data-variant-id="40152678465606"
										data-product-url="https://labelleboucle.fr/products/masque-hydratant-repair-time"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848735302" 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"
												value="40152678465606"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848735302-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX6946848735302-submit title-template--23691076305244__ax_featured_collections_PkRgLX-6946848735302"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="6946848735302" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">Les Secrets de Loly </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="6946848735302"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-6946848735302"
								
							>
								Masque Hydratant Repair Time
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          20,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        20,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
								
							
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>


<div class="card-wrapper product-card-wrapper underline-links-hover">
		<card-product data-secondary="true">
			<a
				href="/products/soin-de-finition-serum"
				id="CardLink-img-template--23691076305244__ax_featured_collections_PkRgLX-8777985261916"
				class="full-unstyled-link"
				aria-labelledby="CardLink-template--23691076305244__ax_featured_collections_PkRgLX-8777985261916 Badge-template--23691076305244__ax_featured_collections_PkRgLX-8777985261916"
			>
				<div
					class="
        card card--standard
         card--media
        
        
        
        
        
      "
					style="--ratio-percent: 100%;"
				>
					<div
						class="card__inner color-scheme-5 gradient ratio"
						style="--ratio-percent: 100%;"
					><div
								class="card__media">
								<div class="media media--transparent media--hover-effect">
									
									<img

										src="//labelleboucle.fr/cdn/shop/files/Soin_de_Finition_Serum.png?v=1719932580&width=1066"
										srcset="//labelleboucle.fr/cdn/shop/files/Soin_de_Finition_Serum.png?v=1719932580&width=165 165w,//labelleboucle.fr/cdn/shop/files/Soin_de_Finition_Serum.png?v=1719932580&width=360 360w,//labelleboucle.fr/cdn/shop/files/Soin_de_Finition_Serum.png?v=1719932580&width=533 533w,//labelleboucle.fr/cdn/shop/files/Soin_de_Finition_Serum.png?v=1719932580 700w
                			"
										sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
										alt="Soin de Finition Sérum"
										class="motion-reduce"
										
										width="700"
										height="700"
									>
									
<img
											lazy-srcset="//labelleboucle.fr/cdn/shop/files/Serum_lifestyle_2.png?v=1719414077&width=165 165w,//labelleboucle.fr/cdn/shop/files/Serum_lifestyle_2.png?v=1719414077&width=360 360w,//labelleboucle.fr/cdn/shop/files/Serum_lifestyle_2.png?v=1719414077&width=533 533w,//labelleboucle.fr/cdn/shop/files/Serum_lifestyle_2.png?v=1719414077 700w
                  "
											lazy-src="//labelleboucle.fr/cdn/shop/files/Serum_lifestyle_2.png?v=1719414077&width=533"
											sizes="(min-width: 2000px) 467px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
											alt=""
											class="motion-reduce secondary-image"
											loading="lazy"
											width="700"
											height="700"
										></div>
							</div><div class="card__content">
							<div class="card__information">
								<div
									class="card__heading"
									
								>
									Soin de Finition Sérum
								</div>
							</div>
							<div class="card__badge top left">
								
									
										
									
										
											
											
								

									
										
										
										
									
										
										
											<span
												id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8777985261916"
												class="badge badge--bottom-left color-new"
											>Coup de coeur</span>
											
</div>
						</div>

						<!-- 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_8777985261916"
										data-swaction="addToWishlist"
										data-product-id="8777985261916"
										data-variant-id="48842166534492"
										data-product-url="https://labelleboucle.fr/products/soin-de-finition-serum"
						>
						</button>
						<!-- Swym Wishlist Plus EPI Button--><div class="quick-add no-js-hidden"><product-form data-section-id="template--23691076305244__ax_featured_collections_PkRgLX"><form method="post" action="/cart/add" id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8777985261916" 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"
												value="48842166534492"
												class="product-variant-id"
												
											>
											<button
												id="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8777985261916-submit"
												type="submit"
												name="add"
												class="quick-add__submit button button--full-width button--secondary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--23691076305244__ax_featured_collections_PkRgLX8777985261916-submit title-template--23691076305244__ax_featured_collections_PkRgLX-8777985261916"
												aria-live="polite"
												data-sold-out-message="true"
												
											>
                    <span><span><svg class="icon icon-cart" aria-hidden="true" focusable="false" width="24" height="28" fill="none" xmlns="http://www.w3.org/2000/svg">
	<path
		d="M20.161 27H3.85a2.8 2.8 0 0 1-2.796-2.923l.614-14.659a2.798 2.798 0 0 1 2.795-2.684h15.085c1.5 0 2.735 1.184 2.795 2.684l.614 14.659A2.8 2.8 0 0 1 20.16 27Z"
		stroke="currentColor" stroke-miterlimit="10" stroke-linejoin="round" />
	<path d="M16.31 9.597V5.575A4.685 4.685 0 0 0 11.621.888a4.685 4.685 0 0 0-4.687 4.687v4.022" stroke="currentColor"
				stroke-miterlimit="10" stroke-linecap="round" stroke-linejoin="round" />
</svg></span></span>
												<span class="sold-out-message hidden">
                      Épuisé
                    </span>


<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="8777985261916" /><input type="hidden" name="section-id" value="template--23691076305244__ax_featured_collections_PkRgLX" /></form></product-form></div></div>
					<div class="card__content">
						<div class="card__information"><span class="visually-hidden">Fournisseur :</span>
								<div class="card__information-vendor-reviews">
									<div class="caption-with-letter-spacing light">La Belle Boucle </div><div yotpo-reviews class="yotpo-reviews">
											<div class="yotpo bottomLine" data-product-id="8777985261916"></div>
										</div></div><h3
								class="card__heading h5"
								
									id="title-template--23691076305244__ax_featured_collections_PkRgLX-8777985261916"
								
							>
								Soin de Finition Sérum
							</h3>

							
								
							

							<div class="card-information">
								<span class="caption-large light"></span>
<div
  class="
    price  price--show-badge"
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span class="price-item price-item--regular">
          14,00€
        </span></div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix promotionnel</span>
      <span class="price-item price-item--sale price-item--last"  style="color: #ff4850" >
        14,00€
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div><span class="badge price__badge-sale color-scheme-18b9d8d0-9335-4a08-aae0-7e99c8630589">
      -0%
    </span></div>

</div>
						</div>
						<div class="card__badge top left">
							
								
									
								
									
										
										
							

								
									
									
									
								
									
									
										<span
											id="NoMediaStandardBadge-template--23691076305244__ax_featured_collections_PkRgLX-8777985261916"
											class="badge badge--bottom-left color-new"
										>Coup de coeur</span>
										
</div>
					</div>
				</div>
			</a>
		</card-product>
	</div>