

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-rating.css?v=179577762467860590411729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-volume-pricing.css?v=56284703641257077881729153276" rel="stylesheet" type="text/css" media="all" />

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-price.css?v=70172745017360139101729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quick-order-list.css?v=135416534718644394131729153277" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quantity-popover.css?v=88697464569499073151758620166" rel="stylesheet" type="text/css" media="all" />
<product-card class="card-wrapper product-miniature product-card-wrapper "
				data-product-id="15124179124609"
				data-product-title="DELINA TRAVEL SET"
				data-product-brand="Parfums de Marly"
				data-product-category="Travel Format"
				data-product-price="210.0"
				data-product-discount="0"
				data-product-variant="3x10ml + Case"
				data-product-variant-id="54620506947969"
				data-product-variant-title="3x10ml + Case"
				data-product-sku="NPM5026PV"
				data-product-url="/products/delina-travel-set-1"
				data-product-image="//uk.parfums-de-marly.com/cdn/shop/files/Delina_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_0ca4ca9a-e76d-4188-b4ab-d557f074d21c.png?v=1759500300&width=533"
				data-product-inventory-quantity="28"
  >
		
    
      <div class="card__label">ONLINE EXCLUSIVE</div>
    
    <div
      class="
        card card--standard
         card--media
        
        
        
        
        
      "
      style="--ratio-percent: 100%;"
    >
      <div
        class="card__inner color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient ratio"
        style="--ratio-percent: 100%;"
      ><div
            class="card__media">
            <div class="media media--transparent media--hover-effect">
              
              
              <img
                srcset="//uk.parfums-de-marly.com/cdn/shop/files/Delina_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_0ca4ca9a-e76d-4188-b4ab-d557f074d21c.png?v=1759500300&width=165 165w,//uk.parfums-de-marly.com/cdn/shop/files/Delina_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_0ca4ca9a-e76d-4188-b4ab-d557f074d21c.png?v=1759500300&width=360 360w,//uk.parfums-de-marly.com/cdn/shop/files/Delina_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_0ca4ca9a-e76d-4188-b4ab-d557f074d21c.png?v=1759500300&width=533 533w,//uk.parfums-de-marly.com/cdn/shop/files/Delina_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_0ca4ca9a-e76d-4188-b4ab-d557f074d21c.png?v=1759500300&width=720 720w,//uk.parfums-de-marly.com/cdn/shop/files/Delina_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_0ca4ca9a-e76d-4188-b4ab-d557f074d21c.png?v=1759500300&width=940 940w,//uk.parfums-de-marly.com/cdn/shop/files/Delina_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_0ca4ca9a-e76d-4188-b4ab-d557f074d21c.png?v=1759500300 1000w
                "
                src="//uk.parfums-de-marly.com/cdn/shop/files/Delina_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_0ca4ca9a-e76d-4188-b4ab-d557f074d21c.png?v=1759500300&width=533"
                sizes="(min-width: 1400px) 317px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                alt="DELINA TRAVEL SET"
                class="motion-reduce"
                
                  loading="lazy"
                
                width="1000"
                height="1000"
              >
              
</div>
          </div><div class="card__content">
          <div class="card__information">
            <h3
              class="card__heading"
              
            >
              <a
                href="/products/delina-travel-set-1"
                id="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-15124179124609"
                class="full-unstyled-link card-product__link"
                aria-labelledby="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-15124179124609 NoMediaStandardBadge-template--24028624748929__ax_featured_collections_RUictJ-15124179124609"
              >
                DELINA TRAVEL SET
              </a>
            </h3>
          </div>
        </div>
      </div>
      <div class="card__content">
        <div class="card__information">
          <h3
            class="card__heading h5"
            
              id="title-template--24028624748929__ax_featured_collections_RUictJ-15124179124609"
            
          >

						

						<a
              href="/products/delina-travel-set-1"
              id="CardLink-template--24028624748929__ax_featured_collections_RUictJ-15124179124609"
              class="full-unstyled-link card-product__link"
              aria-labelledby="CardLink-template--24028624748929__ax_featured_collections_RUictJ-15124179124609 Badge-template--24028624748929__ax_featured_collections_RUictJ-15124179124609"
            >
              <p class="card__title">
                
                  DELINA TRAVEL SET
                
              </p>

            </a>
          </h3>
          
            
              <span class="card__perfume-spacer"></span>
            
          
          <div class="card-information"><span class="caption-large light"></span>
              <link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/bundle.quick-add.css?v=131054677711316398411758620143" rel="stylesheet" type="text/css" media="all" />
<script src="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/product-form.js?v=108568244000931116071758620165" defer="defer"></script>
              <div class="quick-add no-js-hidden"><product-form data-section-id="template--24028624748929__ax_featured_collections_RUictJ"><form method="post" action="/cart/add" id="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124179124609" 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="✓" /><quick-order-select
			data-section="api-complementary-gifts"
			data-url="/products/delina-travel-set-1"
			data-variant-id="54620506947969">
			<select class="visually-hidden"
				name="items[0][id]"
								id="variant-select" aria-label="Select variant">

				

				
				

							
						


							
						


							
						


							
						


				

							
							<option value="54620506947969" data-title="3x10ml + Case">
							3x10ml + Case - £210
							</option>
						


				
			</select>

			<details class="quick-order-select__custom-dropdown">
				<summary class="quick-order-select__selected">
					<div class="quick-order-select__selected-title">
						<span>£210</span>
						<span class="quick-order-select__selected-title-drop">3x10ml + Case<svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
  <path d="M9 1.5 5 4.5 1 1.5" stroke="currentColor" stroke-width="0.75" fill="none" stroke-linecap="round"/>
</svg>
</span>
					</div>
				</summary>
				<ul class="quick-order-select__list">
				
					
						
							<a href="/products/delina-refill-set?variant=54620510224769"
								class="quick-order-select__item"
								data-value="54620510224769" >
								<span>£160</span>
								<span>3x10ml</span>
							</a>
						
					
				

				








				</ul>
			</details><div class="quick-order-select__complementary-gifts"></div>
			</quick-order-select>

			<button
			id="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124179124609-submit"
			type="submit"
			name="add"
			class="quick-add__submit button button--full-width button--secondary  color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient"
			aria-haspopup="dialog"
			aria-labelledby="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124179124609-submit title-template--24028624748929__ax_featured_collections_RUictJ-15124179124609"
			aria-live="polite"
			data-sold-out-message="true"
			
			>
			<span>Add to cart
</span>
			<span class="sold-out-message hidden">
			Sold out
			</span>

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-loading-spinner.css?v=138792313971224789691758620159" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="15124179124609" /><input type="hidden" name="section-id" value="template--24028624748929__ax_featured_collections_RUictJ" /></form>
		</product-form></div>
  
            
</div>
        </div>
      </div>
    </div>
  </product-card>



<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-rating.css?v=179577762467860590411729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-volume-pricing.css?v=56284703641257077881729153276" rel="stylesheet" type="text/css" media="all" />

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-price.css?v=70172745017360139101729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quick-order-list.css?v=135416534718644394131729153277" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quantity-popover.css?v=88697464569499073151758620166" rel="stylesheet" type="text/css" media="all" />
<product-card class="card-wrapper product-miniature product-card-wrapper "
				data-product-id="15124178698625"
				data-product-title="TRAVEL CASE"
				data-product-brand="Parfums de Marly"
				data-product-category="Travel Format"
				data-product-price="110.0"
				data-product-discount="0"
				data-product-variant="Grey"
				data-product-variant-id="54620514648449"
				data-product-variant-title="Grey"
				data-product-sku="NPM5010PV"
				data-product-url="/products/travel-case-atomizer"
				data-product-image="//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315&width=533"
				data-product-inventory-quantity="28"
  >
		
    
      <div class="card__label">ONLINE EXCLUSIVE</div>
    
    <div
      class="
        card card--standard
         card--media
        
        
        
        
        
      "
      style="--ratio-percent: 100%;"
    >
      <div
        class="card__inner color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient ratio"
        style="--ratio-percent: 100%;"
      ><div
            class="card__media">
            <div class="media media--transparent media--hover-effect">
              
              
              <img
                srcset="//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315&width=165 165w,//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315&width=360 360w,//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315&width=533 533w,//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315&width=720 720w,//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315&width=940 940w,//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315&width=1066 1066w,//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315 1500w
                "
                src="//uk.parfums-de-marly.com/cdn/shop/files/atomizer_gris_2_WHITEBACKGROUNDWITHOUTSHADOW_1X1_1b4f6132-e194-4ce4-8e84-df76e153a497.png?v=1759500315&width=533"
                sizes="(min-width: 1400px) 317px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                alt="TRAVEL CASE"
                class="motion-reduce"
                
                  loading="lazy"
                
                width="1500"
                height="1500"
              >
              
</div>
          </div><div class="card__content">
          <div class="card__information">
            <h3
              class="card__heading"
              
            >
              <a
                href="/products/travel-case-atomizer"
                id="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-15124178698625"
                class="full-unstyled-link card-product__link"
                aria-labelledby="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-15124178698625 NoMediaStandardBadge-template--24028624748929__ax_featured_collections_RUictJ-15124178698625"
              >
                TRAVEL CASE
              </a>
            </h3>
          </div>
        </div>
      </div>
      <div class="card__content">
        <div class="card__information">
          <h3
            class="card__heading h5"
            
              id="title-template--24028624748929__ax_featured_collections_RUictJ-15124178698625"
            
          >

						

						<a
              href="/products/travel-case-atomizer"
              id="CardLink-template--24028624748929__ax_featured_collections_RUictJ-15124178698625"
              class="full-unstyled-link card-product__link"
              aria-labelledby="CardLink-template--24028624748929__ax_featured_collections_RUictJ-15124178698625 Badge-template--24028624748929__ax_featured_collections_RUictJ-15124178698625"
            >
              <p class="card__title">
                
                  TRAVEL CASE
                
              </p>

            </a>
          </h3>
          
            
              <span class="card__perfume-spacer"></span>
            
          
          <div class="card-information"><span class="caption-large light"></span>
              <link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/bundle.quick-add.css?v=131054677711316398411758620143" rel="stylesheet" type="text/css" media="all" />
<script src="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/product-form.js?v=108568244000931116071758620165" defer="defer"></script>
              <div class="quick-add no-js-hidden"><product-form data-section-id="template--24028624748929__ax_featured_collections_RUictJ"><form method="post" action="/cart/add" id="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124178698625" 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="✓" /><quick-order-select
			data-section="api-complementary-gifts"
			data-url="/products/travel-case-atomizer"
			data-variant-id="54620514648449">
			<select class="visually-hidden"
				name="items[0][id]"
								id="variant-select" aria-label="Select variant">

				

				
				

							
						

							
						


							
						

							
						


							
						

							
						


							
						

							
						


				

							
							<option value="54620514648449" data-title="Grey">
							Grey - £110
							</option>
						

							
							<option value="54765139952001" data-title="Beige">
							Beige - £110
							</option>
						


				
			</select>

			<details class="quick-order-select__custom-dropdown">
				<summary class="quick-order-select__selected">
					<div class="quick-order-select__selected-title">
						<span>£110</span>
						<span class="quick-order-select__selected-title-drop">Grey<svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
  <path d="M9 1.5 5 4.5 1 1.5" stroke="currentColor" stroke-width="0.75" fill="none" stroke-linecap="round"/>
</svg>
</span>
					</div>
				</summary>
				<ul class="quick-order-select__list">
				

				












				</ul>
			</details><div class="quick-order-select__complementary-gifts"></div>
			</quick-order-select>

			<button
			id="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124178698625-submit"
			type="submit"
			name="add"
			class="quick-add__submit button button--full-width button--secondary  color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient"
			aria-haspopup="dialog"
			aria-labelledby="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124178698625-submit title-template--24028624748929__ax_featured_collections_RUictJ-15124178698625"
			aria-live="polite"
			data-sold-out-message="true"
			
			>
			<span>Add to cart
</span>
			<span class="sold-out-message hidden">
			Sold out
			</span>

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-loading-spinner.css?v=138792313971224789691758620159" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="15124178698625" /><input type="hidden" name="section-id" value="template--24028624748929__ax_featured_collections_RUictJ" /></form>
		</product-form></div>
  
            
</div>
        </div>
      </div>
    </div>
  </product-card>



<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-rating.css?v=179577762467860590411729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-volume-pricing.css?v=56284703641257077881729153276" rel="stylesheet" type="text/css" media="all" />

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-price.css?v=70172745017360139101729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quick-order-list.css?v=135416534718644394131729153277" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quantity-popover.css?v=88697464569499073151758620166" rel="stylesheet" type="text/css" media="all" />
<product-card class="card-wrapper product-miniature product-card-wrapper "
				data-product-id="7087710666937"
				data-product-title="DELINA 30ML"
				data-product-brand="Parfums de Marly"
				data-product-category="Travel Format"
				data-product-price="175.0"
				data-product-discount="0"
				data-product-variant="30ml"
				data-product-variant-id="41528541642937"
				data-product-variant-title="30ml"
				data-product-sku="NPM0010PV"
				data-product-url="/products/delina-30ml"
				data-product-image="//uk.parfums-de-marly.com/cdn/shop/files/DELINA-PERFUME-30-PACK1-1X1_CENTERED.webp?v=1756715625&width=533"
				data-product-inventory-quantity="114"
  >
		
    
      <div class="card__label">Travel</div>
    
    <div
      class="
        card card--standard
         card--media
        
        
        
        
        
      "
      style="--ratio-percent: 100%;"
    >
      <div
        class="card__inner color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient ratio"
        style="--ratio-percent: 100%;"
      ><div
            class="card__media">
            <div class="media media--transparent media--hover-effect">
              
              
              <img
                srcset="//uk.parfums-de-marly.com/cdn/shop/files/DELINA-PERFUME-30-PACK1-1X1_CENTERED.webp?v=1756715625 w
                "
                src="//uk.parfums-de-marly.com/cdn/shop/files/DELINA-PERFUME-30-PACK1-1X1_CENTERED.webp?v=1756715625&width=533"
                sizes="(min-width: 1400px) 317px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                alt="DELINA 30ML"
                class="motion-reduce"
                
                  loading="lazy"
                
                width=""
                height=""
              >
              
</div>
          </div><div class="card__content">
          <div class="card__information">
            <h3
              class="card__heading"
              
            >
              <a
                href="/products/delina-30ml"
                id="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-7087710666937"
                class="full-unstyled-link card-product__link"
                aria-labelledby="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-7087710666937 NoMediaStandardBadge-template--24028624748929__ax_featured_collections_RUictJ-7087710666937"
              >
                DELINA 30ML
              </a>
            </h3>
          </div>
        </div>
      </div>
      <div class="card__content">
        <div class="card__information">
          <h3
            class="card__heading h5"
            
              id="title-template--24028624748929__ax_featured_collections_RUictJ-7087710666937"
            
          >

						

						<a
              href="/products/delina-30ml?variant=41528541642937"
              id="CardLink-template--24028624748929__ax_featured_collections_RUictJ-7087710666937"
              class="full-unstyled-link card-product__link"
              aria-labelledby="CardLink-template--24028624748929__ax_featured_collections_RUictJ-7087710666937 Badge-template--24028624748929__ax_featured_collections_RUictJ-7087710666937"
            >
              <p class="card__title">
                
                  DELINA 30ML
                
              </p>

            </a>
          </h3>
          
            
              <span class="card__perfume">
                
                  <span class="card__perfume-note">Floral</span>
                
                  <span class="card__perfume-note">Rose</span>
                
                  <span class="card__perfume-note">Woody</span>
                
              </span>
            
          
          <div class="card-information"><span class="caption-large light"></span>
              <link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/bundle.quick-add.css?v=131054677711316398411758620143" rel="stylesheet" type="text/css" media="all" />
<script src="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/product-form.js?v=108568244000931116071758620165" defer="defer"></script>
              <div class="quick-add no-js-hidden"><product-form data-section-id="template--24028624748929__ax_featured_collections_RUictJ"><form method="post" action="/cart/add" id="quick-add-template--24028624748929__ax_featured_collections_RUictJ7087710666937" 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="✓" /><quick-order-select
			data-section="api-complementary-gifts"
			data-url="/products/delina-30ml"
			data-variant-id="41528541642937">
			<select class="visually-hidden"
				name="items[0][id]"
								id="variant-select" aria-label="Select variant">

				

				
				

							
						


							
						


							
						


							
								
								<option value="41528541642937" data-title="30ml">
								30ml - £175
								</option>
								
								

				

				
			</select>

			<details class="quick-order-select__custom-dropdown">
				<summary class="quick-order-select__selected">
					<div class="quick-order-select__selected-title">
						<span>£175</span>
						<span class="quick-order-select__selected-title-drop">30ml<svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
  <path d="M9 1.5 5 4.5 1 1.5" stroke="currentColor" stroke-width="0.75" fill="none" stroke-linecap="round"/>
</svg>
</span>
					</div>
				</summary>
				<ul class="quick-order-select__list">
				
					
						
							<a href="/products/delina?variant=40091593572537"
								class="quick-order-select__item"
								data-value="40091593572537" >
								<span>£270</span>
								<span>75ml</span>
							</a>
						
					
				

				







						<li
						class="quick-order-select__item"
						data-value="41528541642937" data-variant-url="/products/delina-30ml?variant=41528541642937" data-section-id="template--24028624748929__ax_featured_collections_RUictJ"
						data-card-id="7087710666937" >
						<span>£175</span>
						<span>30ml</span>
						</li>
						
				</ul>
			</details><div class="quick-order-select__complementary-gifts"></div>
			</quick-order-select>

			<button
			id="quick-add-template--24028624748929__ax_featured_collections_RUictJ7087710666937-submit"
			type="submit"
			name="add"
			class="quick-add__submit button button--full-width button--secondary  color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient"
			aria-haspopup="dialog"
			aria-labelledby="quick-add-template--24028624748929__ax_featured_collections_RUictJ7087710666937-submit title-template--24028624748929__ax_featured_collections_RUictJ-7087710666937"
			aria-live="polite"
			data-sold-out-message="true"
			
			>
			<span>Add to cart
</span>
			<span class="sold-out-message hidden">
			Sold out
			</span>

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-loading-spinner.css?v=138792313971224789691758620159" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="7087710666937" /><input type="hidden" name="section-id" value="template--24028624748929__ax_featured_collections_RUictJ" /></form>
		</product-form></div>
  
            
</div>
        </div>
      </div>
    </div>
  </product-card>



<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-rating.css?v=179577762467860590411729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-volume-pricing.css?v=56284703641257077881729153276" rel="stylesheet" type="text/css" media="all" />

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-price.css?v=70172745017360139101729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quick-order-list.css?v=135416534718644394131729153277" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quantity-popover.css?v=88697464569499073151758620166" rel="stylesheet" type="text/css" media="all" />
<product-card class="card-wrapper product-miniature product-card-wrapper "
				data-product-id="15124178502017"
				data-product-title="ALTHAIR TRAVEL SET"
				data-product-brand="Parfums de Marly"
				data-product-category="Travel Format"
				data-product-price="210.0"
				data-product-discount="0"
				data-product-variant="3x10ml + Case"
				data-product-variant-id="54620511437185"
				data-product-variant-title="3x10ml + Case"
				data-product-sku="NPM5009PV"
				data-product-url="/products/althair-travel-set"
				data-product-image="//uk.parfums-de-marly.com/cdn/shop/files/Althair_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_2866e32d-85b4-48a8-af63-9295ee868f1e.png?v=1759500319&width=533"
				data-product-inventory-quantity="30"
  >
		
    
      <div class="card__label">ONLINE EXCLUSIVE</div>
    
    <div
      class="
        card card--standard
         card--media
        
        
        
        
        
      "
      style="--ratio-percent: 100%;"
    >
      <div
        class="card__inner color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient ratio"
        style="--ratio-percent: 100%;"
      ><div
            class="card__media">
            <div class="media media--transparent media--hover-effect">
              
              
              <img
                srcset="//uk.parfums-de-marly.com/cdn/shop/files/Althair_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_2866e32d-85b4-48a8-af63-9295ee868f1e.png?v=1759500319&width=165 165w,//uk.parfums-de-marly.com/cdn/shop/files/Althair_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_2866e32d-85b4-48a8-af63-9295ee868f1e.png?v=1759500319&width=360 360w,//uk.parfums-de-marly.com/cdn/shop/files/Althair_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_2866e32d-85b4-48a8-af63-9295ee868f1e.png?v=1759500319&width=533 533w,//uk.parfums-de-marly.com/cdn/shop/files/Althair_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_2866e32d-85b4-48a8-af63-9295ee868f1e.png?v=1759500319&width=720 720w,//uk.parfums-de-marly.com/cdn/shop/files/Althair_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_2866e32d-85b4-48a8-af63-9295ee868f1e.png?v=1759500319&width=940 940w,//uk.parfums-de-marly.com/cdn/shop/files/Althair_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_2866e32d-85b4-48a8-af63-9295ee868f1e.png?v=1759500319 1000w
                "
                src="//uk.parfums-de-marly.com/cdn/shop/files/Althair_travelset_pack_2_WHITEBACKGROUNDWITHSHADOW_x3_2866e32d-85b4-48a8-af63-9295ee868f1e.png?v=1759500319&width=533"
                sizes="(min-width: 1400px) 317px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                alt="ALTHAIR TRAVEL SET"
                class="motion-reduce"
                
                  loading="lazy"
                
                width="1000"
                height="1000"
              >
              
</div>
          </div><div class="card__content">
          <div class="card__information">
            <h3
              class="card__heading"
              
            >
              <a
                href="/products/althair-travel-set"
                id="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-15124178502017"
                class="full-unstyled-link card-product__link"
                aria-labelledby="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-15124178502017 NoMediaStandardBadge-template--24028624748929__ax_featured_collections_RUictJ-15124178502017"
              >
                ALTHAIR TRAVEL SET
              </a>
            </h3>
          </div>
        </div>
      </div>
      <div class="card__content">
        <div class="card__information">
          <h3
            class="card__heading h5"
            
              id="title-template--24028624748929__ax_featured_collections_RUictJ-15124178502017"
            
          >

						

						<a
              href="/products/althair-travel-set"
              id="CardLink-template--24028624748929__ax_featured_collections_RUictJ-15124178502017"
              class="full-unstyled-link card-product__link"
              aria-labelledby="CardLink-template--24028624748929__ax_featured_collections_RUictJ-15124178502017 Badge-template--24028624748929__ax_featured_collections_RUictJ-15124178502017"
            >
              <p class="card__title">
                
                  ALTHAIR TRAVEL SET
                
              </p>

            </a>
          </h3>
          
            
              <span class="card__perfume-spacer"></span>
            
          
          <div class="card-information"><span class="caption-large light"></span>
              <link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/bundle.quick-add.css?v=131054677711316398411758620143" rel="stylesheet" type="text/css" media="all" />
<script src="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/product-form.js?v=108568244000931116071758620165" defer="defer"></script>
              <div class="quick-add no-js-hidden"><product-form data-section-id="template--24028624748929__ax_featured_collections_RUictJ"><form method="post" action="/cart/add" id="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124178502017" 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="✓" /><quick-order-select
			data-section="api-complementary-gifts"
			data-url="/products/althair-travel-set"
			data-variant-id="54620511437185">
			<select class="visually-hidden"
				name="items[0][id]"
								id="variant-select" aria-label="Select variant">

				

				
				

							
						


							
						


							
						


							
						


				

							
							<option value="54620511437185" data-title="3x10ml + Case">
							3x10ml + Case - £210
							</option>
						


				
			</select>

			<details class="quick-order-select__custom-dropdown">
				<summary class="quick-order-select__selected">
					<div class="quick-order-select__selected-title">
						<span>£210</span>
						<span class="quick-order-select__selected-title-drop">3x10ml + Case<svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
  <path d="M9 1.5 5 4.5 1 1.5" stroke="currentColor" stroke-width="0.75" fill="none" stroke-linecap="round"/>
</svg>
</span>
					</div>
				</summary>
				<ul class="quick-order-select__list">
				
					
						
							<a href="/products/althair-refill-set?variant=54620512125313"
								class="quick-order-select__item"
								data-value="54620512125313" >
								<span>£160</span>
								<span>3x10ml</span>
							</a>
						
					
				

				








				</ul>
			</details><div class="quick-order-select__complementary-gifts"></div>
			</quick-order-select>

			<button
			id="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124178502017-submit"
			type="submit"
			name="add"
			class="quick-add__submit button button--full-width button--secondary  color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient"
			aria-haspopup="dialog"
			aria-labelledby="quick-add-template--24028624748929__ax_featured_collections_RUictJ15124178502017-submit title-template--24028624748929__ax_featured_collections_RUictJ-15124178502017"
			aria-live="polite"
			data-sold-out-message="true"
			
			>
			<span>Add to cart
</span>
			<span class="sold-out-message hidden">
			Sold out
			</span>

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-loading-spinner.css?v=138792313971224789691758620159" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="15124178502017" /><input type="hidden" name="section-id" value="template--24028624748929__ax_featured_collections_RUictJ" /></form>
		</product-form></div>
  
            
</div>
        </div>
      </div>
    </div>
  </product-card>



<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-rating.css?v=179577762467860590411729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-volume-pricing.css?v=56284703641257077881729153276" rel="stylesheet" type="text/css" media="all" />

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-price.css?v=70172745017360139101729153275" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quick-order-list.css?v=135416534718644394131729153277" rel="stylesheet" type="text/css" media="all" />
<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/quantity-popover.css?v=88697464569499073151758620166" rel="stylesheet" type="text/css" media="all" />
<product-card class="card-wrapper product-miniature product-card-wrapper "
				data-product-id="15179467424129"
				data-product-title="THE COLLECTOR’S COFFRET"
				data-product-brand="Parfums de Marly UK"
				data-product-category="Discovery Sets"
				data-product-price="330.0"
				data-product-discount="0"
				data-product-variant="18x5ml"
				data-product-variant-id="54778818331009"
				data-product-variant-title="18x5ml"
				data-product-sku="NPM98901PV"
				data-product-url="/products/coffret-collectionneur"
				data-product-image="//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165&width=533"
				data-product-inventory-quantity="110"
  >
		
    
      <div class="card__label">NEW</div>
    
    <div
      class="
        card card--standard
         card--media
        
        
        
        
        
      "
      style="--ratio-percent: 100%;"
    >
      <div
        class="card__inner color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient ratio"
        style="--ratio-percent: 100%;"
      ><div
            class="card__media">
            <div class="media media--transparent media--hover-effect">
              
              
              <img
                srcset="//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165&width=165 165w,//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165&width=360 360w,//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165&width=533 533w,//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165&width=720 720w,//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165&width=940 940w,//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165&width=1066 1066w,//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165 1500w
                "
                src="//uk.parfums-de-marly.com/cdn/shop/files/Coffret-Collectionneur-2-avec_ombre-1x1_1_e66374c4-aba0-47a1-800e-eba693fba841.png?v=1759500165&width=533"
                sizes="(min-width: 1400px) 317px, (min-width: 990px) calc((100vw - 130px) / 4), (min-width: 750px) calc((100vw - 120px) / 3), calc((100vw - 35px) / 2)"
                alt="THE COLLECTOR’S COFFRET"
                class="motion-reduce"
                
                  loading="lazy"
                
                width="1500"
                height="1500"
              >
              
</div>
          </div><div class="card__content">
          <div class="card__information">
            <h3
              class="card__heading"
              
            >
              <a
                href="/products/coffret-collectionneur"
                id="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-15179467424129"
                class="full-unstyled-link card-product__link"
                aria-labelledby="StandardCardNoMediaLink-template--24028624748929__ax_featured_collections_RUictJ-15179467424129 NoMediaStandardBadge-template--24028624748929__ax_featured_collections_RUictJ-15179467424129"
              >
                THE COLLECTOR’S COFFRET
              </a>
            </h3>
          </div>
        </div>
      </div>
      <div class="card__content">
        <div class="card__information">
          <h3
            class="card__heading h5"
            
              id="title-template--24028624748929__ax_featured_collections_RUictJ-15179467424129"
            
          >

						

						<a
              href="/products/coffret-collectionneur"
              id="CardLink-template--24028624748929__ax_featured_collections_RUictJ-15179467424129"
              class="full-unstyled-link card-product__link"
              aria-labelledby="CardLink-template--24028624748929__ax_featured_collections_RUictJ-15179467424129 Badge-template--24028624748929__ax_featured_collections_RUictJ-15179467424129"
            >
              <p class="card__title">
                
                  THE COLLECTOR’S COFFRET
                
              </p>

            </a>
          </h3>
          
            
              <span class="card__perfume-spacer"></span>
            
          
          <div class="card-information"><span class="caption-large light"></span>
              <link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/bundle.quick-add.css?v=131054677711316398411758620143" rel="stylesheet" type="text/css" media="all" />
<script src="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/product-form.js?v=108568244000931116071758620165" defer="defer"></script>
              <div class="quick-add no-js-hidden"><div class="card__price-container">
			
			<div class="card__price-container-wrapper">
				
					
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular"><span class="visually-hidden visually-hidden--inline">Regular price</span>
        <span class="price-item price-item--regular">
          £330
        </span></div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Regular price</span>
        
          <span>
            <s class="price-item price-item--regular">
              
                
              
            </s>
          </span>
        
<span class="visually-hidden visually-hidden--inline">Sale price</span>
      <span class="price-item price-item--sale price-item--last">
        £330
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Unit price</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div></div>

					
					<div class="card__price-container-wrapper-title">18x5ml</div>
					
				
			</div>
		</div>
			<product-form data-section-id="template--24028624748929__ax_featured_collections_RUictJ"><form method="post" action="/cart/add" id="quick-add-template--24028624748929__ax_featured_collections_RUictJ15179467424129" 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="54778818331009"
					class="product-variant-id"
					
					><button
					id="quick-add-template--24028624748929__ax_featured_collections_RUictJ15179467424129-submit"
					type="submit"
					name="add"
					class="quick-add__submit button button--full-width button--secondary  color-scheme-ee5a3901-3286-42d2-8c73-6a8171054fda gradient"
					aria-haspopup="dialog"
					aria-labelledby="quick-add-template--24028624748929__ax_featured_collections_RUictJ15179467424129-submit title-template--24028624748929__ax_featured_collections_RUictJ-15179467424129"
					aria-live="polite"
					data-sold-out-message="true"
					
					>
					<span class="card__submit">Add to cart
</span>
					<span class="sold-out-message hidden">
						Sold out
					</span>

<link href="//uk.parfums-de-marly.com/cdn/shop/t/46/assets/component-loading-spinner.css?v=138792313971224789691758620159" rel="stylesheet" type="text/css" media="all" />

<div class="loading__spinner hidden">
  <svg
    aria-hidden="true"
    focusable="false"
    class="spinner"
    viewBox="0 0 66 66"
    xmlns="http://www.w3.org/2000/svg"
  >
    <circle class="path" fill="none" stroke-width="6" cx="33" cy="33" r="30"></circle>
  </svg>
</div>
</button><input type="hidden" name="product-id" value="15179467424129" /><input type="hidden" name="section-id" value="template--24028624748929__ax_featured_collections_RUictJ" /></form></product-form>
		
</div>
  
            
</div>
        </div>
      </div>
    </div>
  </product-card>

CgoKCjxzdHlsZSBkYXRhLXNob3BpZnk+CgkKCQkucHVzaC1jb2xsZWN0aW9uLXRlbXBsYXRlLS0yNDAyODYyNDc0ODkyOV9fYXhfZmVhdHVyZWRfY29sbGVjdGlvbnNfUlVpY3RKLSAuYnV0dG9uIHsKCQkJYmFja2dyb3VuZC1jb2xvcjp0cmFuc3BhcmVudDsKCQl9CgkJCgkJQG1lZGlhIHNjcmVlbiBhbmQgKG1heC13aWR0aDogNzUwcHgpIHsKCQkJLnB1c2gtY29sbGVjdGlvbi10ZW1wbGF0ZS0tMjQwMjg2MjQ3NDg5MjlfX2F4X2ZlYXR1cmVkX2NvbGxlY3Rpb25zX1JVaWN0Si0gLmJ1dHRvbiB7CgkJCQljb2xvcjogI0ZGRkZGRjsKCQkJCWJhY2tncm91bmQtY29sb3I6ICMxMjEyMTI7CgkJCQlib3JkZXItY29sb3I6ICNGRkZGRkY7CgkJCX0KCQl9CgkKPC9zdHlsZT4KCgoK